wip text buffer for terminal

Cargo.lock

@@ -21,12 +21,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "allocator-api2"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
-
 [[package]]
 name = "arrayvec"
 version = "0.7.6"
@@ -186,15 +180,6 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
 
-[[package]]
-name = "castaway"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0abae9be0aaf9ea96a3b1b8b1b55c602ca751eba1b1500220cea4ecbafe7c0d5"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "cfg-if"
 version = "1.0.1"
@@ -208,21 +193,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
 dependencies = [
  "termcolor",
- "unicode-width 0.1.14",
+ "unicode-width",
-]
-
-[[package]]
-name = "compact_str"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdb1325a1cece981e8a296ab8f0f9b63ae357bd0784a9faaf548cc7b480707a"
-dependencies = [
- "castaway",
- "cfg-if",
- "itoa",
- "rustversion",
- "ryu",
- "static_assertions",
 ]
 
 [[package]]
@@ -422,15 +393,6 @@ dependencies = [
  "defmt 0.3.100",
 ]
 
-[[package]]
-name = "deranged"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
-dependencies = [
- "powerfmt",
-]
-
 [[package]]
 name = "diff"
 version = "0.1.13"
@@ -736,15 +698,6 @@ dependencies = [
  "defmt 0.3.100",
 ]
 
-[[package]]
-name = "embedded-graphics-unicodefonts"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ef96f7e6453093b9ffc738fb025f1a14c31f7f67a5d587db99beb23ab8b433a"
-dependencies = [
- "embedded-graphics",
-]
-
 [[package]]
 name = "embedded-hal"
 version = "0.2.7"
@@ -891,12 +844,6 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
-[[package]]
-name = "foldhash"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
-
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -1025,11 +972,6 @@ name = "hashbrown"
 version = "0.15.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
-dependencies = [
- "allocator-api2",
- "equivalent",
- "foldhash",
-]
 
 [[package]]
 name = "heapless"
@@ -1041,12 +983,6 @@ dependencies = [
  "stable_deref_trait",
 ]
 
-[[package]]
-name = "heck"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
-
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -1070,33 +1006,14 @@ 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",
 ]
 
-[[package]]
-name = "indoc"
-version = "2.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
-
-[[package]]
-name = "instability"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf9fed6d91cfb734e7476a06bde8300a1b94e217e1b523b6f0cd1a01998c71d"
-dependencies = [
- "darling",
- "indoc",
- "proc-macro2",
- "quote",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "is-terminal"
 version = "0.4.16"
@@ -1117,15 +1034,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "itertools"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "413ee7dfc52ee1a4949ceeb7dbc8a33f2d6c088194d9f922fb8318faf1f01186"
-dependencies = [
- "either",
-]
-
 [[package]]
 name = "itertools"
 version = "0.14.0"
@@ -1135,12 +1043,6 @@ dependencies = [
  "either",
 ]
 
-[[package]]
-name = "itoa"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
-
 [[package]]
 name = "js-sys"
 version = "0.3.77"
@@ -1151,16 +1053,6 @@ dependencies = [
  "wasm-bindgen",
 ]
 
-[[package]]
-name = "kasuari"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "def1b67294a9fdc95eeeeafd1209c7a1b8a82aa0bf80ac2ab2a7d0318e9c7622"
-dependencies = [
- "hashbrown",
- "thiserror 2.0.12",
-]
-
 [[package]]
 name = "keccak"
 version = "0.1.5"
@@ -1255,15 +1147,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "line-clipping"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51a1679740111eb63b7b4cb3c97b1d5d9f82e142292a25edcfdb4120a48b3880"
-dependencies = [
- "bitflags 2.9.1",
-]
-
 [[package]]
 name = "litrs"
 version = "0.4.1"
@@ -1286,15 +1169,6 @@ version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
 
-[[package]]
-name = "lru"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f8cc7106155f10bdf99a6f379688f543ad6596a415375b36a59a054ceda1198"
-dependencies = [
- "hashbrown",
-]
-
 [[package]]
 name = "memchr"
 version = "2.7.5"
@@ -1307,17 +1181,6 @@ version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3c8dda44ff03a2f238717214da50f65d5a53b45cd213a7370424ffdb6fae815"
 
-[[package]]
-name = "mousefood"
-version = "0.2.1"
-source = "git+https://github.com/j-g00da/mousefood#8d78348cebad78ee9929fd09b656bf7382fcd4b5"
-dependencies = [
- "embedded-graphics",
- "embedded-graphics-unicodefonts",
- "ratatui-core",
- "thiserror 2.0.12",
-]
-
 [[package]]
 name = "nb"
 version = "0.1.3"
@@ -1339,12 +1202,6 @@ version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "650eef8c711430f1a879fdd01d4745a7deea475becfb90269c06775983bbf086"
 
-[[package]]
-name = "num-conv"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
-
 [[package]]
 name = "num-traits"
 version = "0.2.19"
@@ -1479,6 +1336,7 @@ checksum = "5be167a7af36ee22fe3115051bc51f6e6c7054c9348e28deb4f49bd6f705a315"
 name = "picocalc-os-rs"
 version = "0.1.0"
 dependencies = [
+ "bitflags 2.9.1",
  "bt-hci",
  "cortex-m",
  "cortex-m-rt",
@@ -1497,10 +1355,8 @@ dependencies = [
  "embedded-hal-async",
  "embedded-hal-bus",
  "embedded-sdmmc",
- "mousefood",
  "panic-probe",
  "portable-atomic",
- "ratatui",
  "spin",
  "st7365p-lcd",
  "static_cell",
@@ -1617,12 +1473,6 @@ dependencies = [
  "critical-section",
 ]
 
-[[package]]
-name = "powerfmt"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
-
 [[package]]
 name = "precomputed-hash"
 version = "0.1.1"
@@ -1699,56 +1549,6 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 
-[[package]]
-name = "ratatui"
-version = "0.30.0-alpha.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63bfff7501cc6892821f54f1133661e0534413342c8e8efbb41af0ffccdcea45"
-dependencies = [
- "instability",
- "ratatui-core",
- "ratatui-widgets",
-]
-
-[[package]]
-name = "ratatui-core"
-version = "0.1.0-alpha.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "353047185fbfb81ee05a3f8c573956adb2aa9a505da47fb150c18388806f5e22"
-dependencies = [
- "bitflags 2.9.1",
- "compact_str",
- "hashbrown",
- "indoc",
- "itertools 0.14.0",
- "kasuari",
- "lru",
- "strum",
- "thiserror 2.0.12",
- "unicode-segmentation",
- "unicode-truncate",
- "unicode-width 0.2.0",
-]
-
-[[package]]
-name = "ratatui-widgets"
-version = "0.3.0-alpha.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fab55e77e0421bb88944cc0262317688e039d0e58518195f13a6e689f3e22f42"
-dependencies = [
- "bitflags 2.9.1",
- "hashbrown",
- "indoc",
- "instability",
- "itertools 0.14.0",
- "line-clipping",
- "ratatui-core",
- "strum",
- "time",
- "unicode-segmentation",
- "unicode-width 0.2.0",
-]
-
 [[package]]
 name = "redox_syscall"
 version = "0.5.13"
@@ -1853,12 +1653,6 @@ version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
 
-[[package]]
-name = "ryu"
-version = "1.0.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
-
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -1947,10 +1741,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",
 ]
 
@@ -1960,12 +1754,6 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
 [[package]]
 name = "static_cell"
 version = "2.1.1"
@@ -1993,28 +1781,6 @@ version = "0.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
-[[package]]
-name = "strum"
-version = "0.27.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f64def088c51c9510a8579e3c5d67c65349dcf755e5479ad3d010aa6454e2c32"
-dependencies = [
- "strum_macros",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.27.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77a8c5abcaf0f9ce05d62342b7d298c346515365c36b673df4ebe3ced01fde8"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.104",
-]
-
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -2116,24 +1882,6 @@ dependencies = [
  "syn 2.0.104",
 ]
 
-[[package]]
-name = "time"
-version = "0.3.41"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
-dependencies = [
- "deranged",
- "num-conv",
- "powerfmt",
- "time-core",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
-
 [[package]]
 name = "tiny-keccak"
 version = "2.0.2"
@@ -2188,35 +1936,12 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 
-[[package]]
-name = "unicode-segmentation"
-version = "1.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
-
-[[package]]
-name = "unicode-truncate"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fbf03860ff438702f3910ca5f28f8dac63c1c11e7efb5012b8b175493606330"
-dependencies = [
- "itertools 0.13.0",
- "unicode-segmentation",
- "unicode-width 0.2.0",
-]
-
 [[package]]
 name = "unicode-width"
 version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
 
-[[package]]
-name = "unicode-width"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
-
 [[package]]
 name = "unicode-xid"
 version = "0.2.6"

Cargo.toml

@@ -65,18 +65,16 @@ 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"
-talc = "4.4.3"
 
 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" }
+# st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs" }
-mousefood = "0.2.1"
+st7365p-lcd = { path = "../ST7365P-lcd-rs" }
-ratatui = { version = "0.30.0-alpha.4", default-features = false }
-spin = "0.10.0"
 
-[patch.crates-io]
+static_cell = "2.1.1"
-mousefood = { git = "https://github.com/j-g00da/mousefood" }
+bitflags = "2.9.1"
+talc = "4.4.3"
+spin = "0.10.0"

src/display.rs

@@ -1,118 +1,141 @@
+use defmt::info;
 use embassy_rp::{
     gpio::{Level, Output},
     peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
-    spi::{Blocking, Spi},
+    spi::{Async, Spi},
 };
 use embassy_time::{Delay, Timer};
 use embedded_graphics::{
-    Drawable, Pixel,
+    Drawable,
-    pixelcolor::{Rgb565, raw::RawU16},
+    mono_font::{MonoFont, MonoTextStyle, ascii::FONT_10X20},
-    prelude::{DrawTarget, OriginDimensions, Point, Primitive, RawData, RgbColor, Size},
+    pixelcolor::Rgb565,
-    primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
+    prelude::{Point, WebColors},
+    text::{Baseline, Text, TextStyle},
 };
 use embedded_hal_bus::spi::ExclusiveDevice;
-use mousefood::prelude::*;
+use st7365p_lcd::{FrameBuffer, ST7365P};
-use ratatui::{
+
-    Frame, Terminal,
+type SPI = Spi<'static, SPI1, Async>;
-    style::{Color, Style},
+
-    widgets::Paragraph,
+type FRAMEBUFFER = FrameBuffer<
-};
+    SCREEN_WIDTH,
-use st7365p_lcd::ST7365P;
+    SCREEN_HEIGHT,
+    ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
+    Output<'static>,
+    Output<'static>,
+>;
+
+const SCREEN_WIDTH: usize = 320;
+const SCREEN_HEIGHT: usize = 320;
+const SCREEN_ROWS: usize = 15;
+const SCREEN_COLS: usize = 31;
+const FONT: MonoFont = FONT_10X20;
+const COLOR: Rgb565 = Rgb565::CSS_LAWN_GREEN;
 
 #[embassy_executor::task]
-pub async fn display_task(
+pub async fn display_task(spi: SPI, cs: PIN_13, data: PIN_14, reset: PIN_15) {
-    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(
+    let display = ST7365P::new(
         spi_device,
         Output::new(data, Level::Low),
         Some(Output::new(reset, Level::High)),
         false,
         true,
-        320,
+        SCREEN_WIDTH as u32,
-        320,
+        SCREEN_HEIGHT as u32,
     );
-    display.init(&mut Delay).unwrap();
+    let mut framebuffer: FRAMEBUFFER = FrameBuffer::new(display);
-    display.set_address_window(0, 0, 319, 319).unwrap();
-    display.set_custom_orientation(0x40).unwrap(); // inverts X axis (reverts the natural mirroring)
 
-    let mut virtual_display = VirtualDisplay::new(display, 320, 320);
+    framebuffer.init(&mut Delay).await.unwrap();
+    framebuffer.display.set_offset(0, 0);
+    framebuffer
+        .display
+        .set_custom_orientation(0x60)
+        .await
+        .unwrap();
 
-    let backend = EmbeddedBackend::new(&mut virtual_display, EmbeddedBackendConfig::default());
+    let mut textbuffer = TextBuffer::new();
-    let mut terminal = Terminal::new(backend).unwrap();
+    textbuffer.fill('A');
+    textbuffer.draw(&mut framebuffer);
+    info!("finished rendering");
 
     loop {
-        terminal.draw(draw).unwrap();
+        framebuffer.draw().await.unwrap();
-    }
+        Timer::after_millis(500).await;
-    loop {
-        Timer::after_millis(100).await
     }
 }
 
-fn draw(frame: &mut Frame) {
+pub struct Cursor {
-    let greeting = Paragraph::new("Hello World!\nLine2").style(Style::new().red());
+    x: u16,
-    frame.render_widget(greeting, frame.area());
+    y: u16,
 }
 
-/// simple abstraction over real display & resolution to reduce frame buffer size
+impl Cursor {
-/// by cutting the resolution by 1/4
+    fn new(x: u16, y: u16) -> Self {
-struct VirtualDisplay {
+        Self { x, y }
-    display: ST7365P<
+    }
-        ExclusiveDevice<Spi<'static, SPI1, Blocking>, Output<'static>, Delay>,
-        Output<'static>,
-        Output<'static>,
-    >,
-    width: u32,
-    height: u32,
 }
 
-impl VirtualDisplay {
+pub struct TextBuffer {
-    pub fn new(
+    grid: [[Option<char>; SCREEN_COLS]; SCREEN_ROWS],
-        display: ST7365P<
+    cursor: Cursor,
-            ExclusiveDevice<Spi<'static, SPI1, Blocking>, Output<'static>, Delay>,
+}
-            Output<'static>,
+
-            Output<'static>,
+impl TextBuffer {
-        >,
+    pub fn new() -> Self {
-        width: u32,
-        height: u32,
-    ) -> Self {
         Self {
-            display,
+            grid: [[None; SCREEN_COLS]; SCREEN_ROWS],
-            width: width / 2,
+            cursor: Cursor { x: 0, y: 0 },
-            height: height / 2,
+        }
+    }
+
+    /// writes char at cursor
+    pub fn write_char(&mut self, ch: char) {
+        for (i, row) in self.grid.iter_mut().enumerate() {
+            for (j, col) in row.iter_mut().enumerate() {
+                if i as u16 == self.cursor.x && j as u16 == self.cursor.y {
+                    *col = Some(ch)
+                }
+            }
+        }
+    }
+
+    /// fills text buffer with char
+    pub fn fill(&mut self, ch: char) {
+        for i in 0..SCREEN_ROWS {
+            for j in 0..SCREEN_COLS {
+                self.cursor = Cursor::new(i as u16, j as u16);
+                self.write_char(ch);
+            }
+        }
+    }
+
+    pub fn scroll_up(&mut self) {
+        let (top, bottom) = self.grid.split_at_mut(SCREEN_ROWS - 1);
+        for (dest, src) in top.iter_mut().zip(&bottom[1..]) {
+            dest.copy_from_slice(src);
+        }
+
+        self.grid[SCREEN_ROWS - 1].fill(None);
+    }
+
+    pub fn draw(&mut self, target: &mut FRAMEBUFFER) {
+        let baseline = TextStyle::with_baseline(Baseline::Top);
+        let style = MonoTextStyle::new(&FONT, COLOR);
+
+        for (i, row) in self.grid.iter().enumerate() {
+            for (j, cell) in row.iter().enumerate() {
+                if let Some(ch) = cell {
+                    let pos = Point::new(
+                        (j as i32) * FONT.character_size.width as i32,
+                        (i as i32) * FONT.character_size.height as i32 + baseline.baseline as i32,
+                    );
+
+                    Text::new(ch.as_ascii().unwrap().as_str(), pos, style)
+                        .draw(target)
+                        .unwrap();
+                }
+            }
         }
     }
 }
-
-impl DrawTarget for VirtualDisplay {
-    type Color = Rgb565;
-    type Error = ();
-
-    fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
-    where
-        I: IntoIterator<Item = Pixel<Self::Color>>,
-    {
-        for Pixel(coord, color) in pixels.into_iter() {
-            let px = coord.x as u16 * 2;
-            let py = coord.y as u16 * 2;
-            let raw_color = RawU16::from(color).into_inner();
-
-            // Draw the 2x2 block on the underlying hardware
-            self.display.set_pixel(px, py, raw_color)?;
-            self.display.set_pixel(px + 1, py, raw_color)?;
-            self.display.set_pixel(px, py + 1, raw_color)?;
-            self.display.set_pixel(px + 1, py + 1, raw_color)?;
-        }
-        Ok(())
-    }
-}
-
-impl OriginDimensions for VirtualDisplay {
-    fn size(&self) -> Size {
-        Size::new(self.width, self.height)
-    }
-}

src/main.rs

@@ -1,4 +1,5 @@
 #![feature(impl_trait_in_assoc_type)]
+#![feature(ascii_char)]
 #![no_std]
 #![no_main]
 
@@ -22,7 +23,6 @@ use embassy_time::Timer;
 use embedded_hal_bus::spi::ExclusiveDevice;
 use embedded_sdmmc::asynchronous::{File, SdCard, ShortFileName, VolumeIdx, VolumeManager};
 use static_cell::StaticCell;
-use talc::*;
 
 mod peripherals;
 use peripherals::{keyboard::KeyEvent, peripherals_task};
@@ -33,16 +33,6 @@ embassy_rp::bind_interrupts!(struct Irqs {
     I2C1_IRQ => i2c::InterruptHandler<I2C1>;
 });
 
-static mut ARENA: [u8; 400_000] = [0; 400_000];
-
-#[global_allocator]
-static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> = Talc::new(unsafe {
-    // if we're in a hosted environment, the Rust runtime may allocate before
-    // main() is called, so we need to initialize the arena automatically
-    ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut()))
-})
-.lock();
-
 #[embassy_executor::main]
 async fn main(spawner: Spawner) {
     let p = embassy_rp::init(Default::default());
@@ -50,24 +40,21 @@ async fn main(spawner: Spawner) {
     static KEYBOARD_EVENTS: StaticCell<Channel<NoopRawMutex, KeyEvent, 10>> = StaticCell::new();
     let keyboard_events = KEYBOARD_EVENTS.init(Channel::new());
 
-    // configure keyboard event handler
+    // // configure keyboard event handler
-    let config = i2c::Config::default();
+    // let mut config = i2c::Config::default();
-    let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
+    // config.frequency = 100_000;
-    spawner
+    // let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
-        .spawn(peripherals_task(i2c1, keyboard_events.sender()))
+    // spawner
-        .unwrap();
+    //     .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_blocking(p.SPI1, p.PIN_10, p.PIN_11, p.PIN_12, config);
+    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();
-
-    let receiver = keyboard_events.receiver();
-    loop {
-        let key = receiver.receive().await;
-        info!("got key: {}", key.key as u8);
-    }
 }

src/peripherals/battery.rs

@@ -1,20 +0,0 @@
-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,3 +1,4 @@
+use defmt::{info, warn};
 use embassy_rp::{
     i2c::{Async, I2c},
     peripherals::I2C1,
@@ -7,6 +8,8 @@ use embassy_sync::{
     channel::Sender,
 };
 
+use crate::peripherals::PERIPHERAL_BUS;
+
 const REG_ID_KEY: u8 = 0x04;
 const REG_ID_FIF: u8 = 0x09;
 
@@ -14,10 +17,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(
+pub async fn read_keyboard_fifo(channel: &mut Sender<'static, NoopRawMutex, KeyEvent, 10>) {
-    i2c: &mut I2c<'static, I2C1, Async>,
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-    channel: &mut Sender<'static, NoopRawMutex, KeyEvent, 10>,
+    let i2c = i2c.as_mut().unwrap();
-) {
+
     let mut key_status = [0_u8; 1];
 
     if i2c
@@ -25,9 +28,8 @@ pub async fn read_keyboard_fifo(
         .await
         .is_ok()
     {
-        // TODO: use caps & num lock
+        let _caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
-        let caps = key_status[0] & KEY_CAPSLOCK == KEY_CAPSLOCK;
+        let _num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
-        let num = key_status[0] & KEY_NUMLOCK == KEY_NUMLOCK;
         let fifo_count = key_status[0] & KEY_COUNT_MASK;
 
         if fifo_count >= 1 {
@@ -38,78 +40,99 @@ pub async fn read_keyboard_fifo(
                 .await
                 .is_ok()
             {
-                if let Ok(state) = KeyState::try_from(event[0]) {
+                channel
-                    if let Ok(key) = KeyCode::try_from(event[1]) {
+                    .try_send(KeyEvent {
-                        let _ = channel.try_send(KeyEvent { key, state });
+                        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,
+    Pressed = 1,
-    Hold,
+    Hold = 2,
-    Released,
+    Released = 3,
 }
 
-impl TryFrom<u8> for KeyState {
+impl From<u8> for KeyState {
-    type Error = ();
+    fn from(value: u8) -> Self {
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
-            0 => Ok(KeyState::Idle),
+            1 => KeyState::Pressed,
-            1 => Ok(KeyState::Pressed),
+            2 => KeyState::Hold,
-            2 => Ok(KeyState::Hold),
+            3 => KeyState::Released,
-            3 => Ok(KeyState::Released),
+            0 | _ => KeyState::Idle,
-            _ => 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,
@@ -117,11 +140,7 @@ pub enum KeyCode {
     End = 0xD5,
     PageUp = 0xD6,
     PageDown = 0xD7,
-
-    // Locks
     CapsLock = 0xC1,
-
-    // Function keys
     F1 = 0x81,
     F2 = 0x82,
     F3 = 0x83,
@@ -132,55 +151,57 @@ pub enum KeyCode {
     F8 = 0x88,
     F9 = 0x89,
     F10 = 0x90,
+    Char(char),
+    Unknown(u8),
 }
 
-impl TryFrom<u8> for KeyCode {
+impl From<u8> for KeyCode {
-    type Error = ();
+    fn from(value: u8) -> Self {
-
-    fn try_from(value: u8) -> Result<Self, Self::Error> {
-        use KeyCode::*;
         match value {
-            0x01 => Ok(JoyUp),
+            0x01 => Self::JoyUp,
-            0x02 => Ok(JoyDown),
+            0x02 => Self::JoyDown,
-            0x03 => Ok(JoyLeft),
+            0x03 => Self::JoyLeft,
-            0x04 => Ok(JoyRight),
+            0x04 => Self::JoyRight,
-            0x05 => Ok(JoyCenter),
+            0x05 => Self::JoyCenter,
-            0x06 => Ok(BtnLeft1),
+            0x06 => Self::BtnLeft1,
-            0x07 => Ok(BtnRight1),
+            0x07 => Self::BtnRight1,
-            0x08 => Ok(Backspace),
+            0x08 => Self::Backspace,
-            0x09 => Ok(Tab),
+            0x09 => Self::Tab,
-            0x0A => Ok(Enter),
+            0x0A => Self::Enter,
-            0x11 => Ok(BtnLeft2),
+            0x11 => Self::BtnLeft2,
-            0x12 => Ok(BtnRight2),
+            0x12 => Self::BtnRight2,
-            0xA1 => Ok(ModAlt),
+            0xA1 => Self::ModAlt,
-            0xA2 => Ok(ModShiftLeft),
+            0xA2 => Self::ModShiftLeft,
-            0xA3 => Ok(ModShiftRight),
+            0xA3 => Self::ModShiftRight,
-            0xA4 => Ok(ModSym),
+            0xA4 => Self::ModSym,
-            0xA5 => Ok(ModCtrl),
+            0xA5 => Self::ModCtrl,
-            0xB1 => Ok(Esc),
+            0xB1 => Self::Esc,
-            0xB4 => Ok(Left),
+            0xB4 => Self::Left,
-            0xB5 => Ok(Up),
+            0xB5 => Self::Up,
-            0xB6 => Ok(Down),
+            0xB6 => Self::Down,
-            0xB7 => Ok(Right),
+            0xB7 => Self::Right,
-            0xC1 => Ok(CapsLock),
+            0xC1 => Self::CapsLock,
-            0xD0 => Ok(Break),
+            0xD0 => Self::Break,
-            0xD1 => Ok(Insert),
+            0xD1 => Self::Insert,
-            0xD2 => Ok(Home),
+            0xD2 => Self::Home,
-            0xD4 => Ok(Del),
+            0xD4 => Self::Del,
-            0xD5 => Ok(End),
+            0xD5 => Self::End,
-            0xD6 => Ok(PageUp),
+            0xD6 => Self::PageUp,
-            0xD7 => Ok(PageDown),
+            0xD7 => Self::PageDown,
-            0x81 => Ok(F1),
+            0x81 => Self::F1,
-            0x82 => Ok(F2),
+            0x82 => Self::F2,
-            0x83 => Ok(F3),
+            0x83 => Self::F3,
-            0x84 => Ok(F4),
+            0x84 => Self::F4,
-            0x85 => Ok(F5),
+            0x85 => Self::F5,
-            0x86 => Ok(F6),
+            0x86 => Self::F6,
-            0x87 => Ok(F7),
+            0x87 => Self::F7,
-            0x88 => Ok(F8),
+            0x88 => Self::F8,
-            0x89 => Ok(F9),
+            0x89 => Self::F9,
-            0x90 => Ok(F10),
+            0x90 => Self::F10,
-            _ => Err(()),
+            _ => match char::from_u32(value as u32) {
+                Some(c) => Self::Char(c),
+                None => Self::Unknown(value),
+            },
         }
     }
 }

src/peripherals/mod.rs

@@ -1,72 +1,106 @@
 //! 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, mutex::Mutex};
+use embassy_sync::{
+    blocking_mutex::raw::NoopRawMutex, channel::Sender, lazy_lock::LazyLock, 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::read_keyboard_fifo;
+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_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_INT: u8 = 0x03;
-const REG_ID_BK2: u8 = 0x0A;
-const REG_ID_C64_MTX: u8 = 0x0c;
-const REG_ID_C64_JS: u8 = 0x0d;
 
 #[embassy_executor::task]
 pub async fn peripherals_task(
-    mut i2c: I2c<'static, I2C1, Async>,
+    i2c: I2CBUS,
     mut keyboard_channel: Sender<'static, NoopRawMutex, KeyEvent, 10>,
 ) {
     Timer::after(embassy_time::Duration::from_millis(100)).await;
 
-    #[cfg(feature = "defmt")]
+    PERIPHERAL_BUS.get().lock().await.replace(i2c);
-    {
+
-        let mut ver = [0_u8; 1];
+    configure_keyboard(200, 100).await;
-        if let Ok(firm_ver) = i2c.write_read_async(MCU_ADDR, [REG_ID_VER], &mut ver).await {
+    set_lcd_backlight(255).await;
-            info!("stm32 firmware version: v{}", ver[0]);
+    set_key_backlight(0).await;
-        }
+
+    loop {
+        Timer::after(Duration::from_millis(200)).await;
+        read_keyboard_fifo(&mut keyboard_channel).await;
     }
-
+}
-    let i2c: Mutex<NoopRawMutex, I2c<'static, I2C1, Async>> = Mutex::new(i2c);
+
-
+/// return major & minor mcu version
-    join(
+async fn get_version() -> (u8, u8) {
-        async {
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-            loop {
+    let i2c = i2c.as_mut().unwrap();
-                Timer::after(Duration::from_secs(10)).await;
+
-                let mut guard = i2c.lock().await;
+    let mut ver = [0_u8; 1];
-                read_battery(&mut guard).await;
+    let _ = i2c.write_read_async(MCU_ADDR, [REG_ID_VER], &mut ver).await;
-            }
+
-        },
+    (ver[0] >> 4, ver[0] & 0x0F)
-        async {
+}
-            loop {
+
-                Timer::after(Duration::from_millis(50)).await;
+const REG_ID_BKL: u8 = 0x05;
-                let mut guard = i2c.lock().await;
+pub async fn set_lcd_backlight(brightness: u8) {
-                read_keyboard_fifo(&mut guard, &mut keyboard_channel).await;
+    let mut i2c = PERIPHERAL_BUS.get().lock().await;
-            }
+    let i2c = i2c.as_mut().unwrap();
-        },
+
-    )
+    let _ = i2c
-    .await;
+        .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]
 }