setup basic file structure

kernel/src/display.rs

@@ -0,0 +1,87 @@
+use core::sync::atomic::Ordering;
+
+use defmt::info;
+use embassy_rp::{
+    gpio::{Level, Output},
+    peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
+    spi::{Async, Spi},
+};
+use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, signal::Signal};
+use embassy_time::{Delay, Instant, Timer};
+use embedded_graphics::{
+    Drawable,
+    draw_target::DrawTarget,
+    mono_font::{MonoTextStyle, ascii::FONT_10X20},
+    pixelcolor::Rgb565,
+    prelude::{Dimensions, Point, RgbColor, Size},
+    primitives::Rectangle,
+    text::{Alignment, Text},
+};
+use embedded_hal_bus::spi::ExclusiveDevice;
+use portable_atomic::AtomicBool;
+use st7365p_lcd::{FrameBuffer, ST7365P};
+
+use crate::LAST_TEXT_RECT;
+
+const SCREEN_WIDTH: usize = 320;
+const SCREEN_HEIGHT: usize = 320;
+
+pub static DISPLAY_SIGNAL: Signal<ThreadModeRawMutex, ()> = Signal::new();
+
+pub async fn display_handler(
+    spi: Spi<'static, SPI1, Async>,
+    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,
+        Delay,
+    );
+    let mut framebuffer: FrameBuffer<
+        SCREEN_WIDTH,
+        SCREEN_HEIGHT,
+        { SCREEN_WIDTH * SCREEN_HEIGHT },
+    > = FrameBuffer::new();
+    display.init().await.unwrap();
+    display.set_custom_orientation(0x40).await.unwrap();
+    framebuffer.draw(&mut display).await.unwrap();
+    display.set_on().await.unwrap();
+
+    DISPLAY_SIGNAL.signal(());
+
+    loop {
+        DISPLAY_SIGNAL.wait().await;
+
+        let text_string = crate::STRING.lock().await.clone();
+
+        let text = Text::with_alignment(
+            &text_string,
+            Point::new(160, 160),
+            MonoTextStyle::new(&FONT_10X20, Rgb565::RED),
+            Alignment::Center,
+        );
+
+        {
+            let rect = LAST_TEXT_RECT.lock().await;
+            if let Some(rect) = *rect.borrow() {
+                framebuffer.fill_solid(&rect, Rgb565::BLACK).unwrap();
+            }
+            *rect.borrow_mut() = Some(text.bounding_box());
+        }
+
+        text.draw(&mut framebuffer).unwrap();
+
+        let start = Instant::now();
+        framebuffer
+            .partial_draw_batched(&mut display)
+            .await
+            .unwrap();
+        info!("Elapsed {}ms", start.elapsed().as_millis());
+    }
+}

kernel/src/main.rs

@@ -0,0 +1,95 @@
+#![feature(impl_trait_in_assoc_type)]
+#![feature(ascii_char)]
+#![cfg_attr(not(test), no_std)]
+#![cfg_attr(not(test), no_main)]
+
+use crate::{
+    display::DISPLAY_SIGNAL,
+    peripherals::keyboard::{KeyCode, KeyState, read_keyboard_fifo},
+};
+
+use {defmt_rtt as _, panic_probe as _};
+
+use core::cell::RefCell;
+use embassy_executor::Spawner;
+use embassy_futures::join::join;
+use embassy_rp::peripherals::I2C1;
+use embassy_rp::{i2c, i2c::I2c, spi};
+use embassy_sync::blocking_mutex::raw::ThreadModeRawMutex;
+use embassy_sync::mutex::Mutex;
+use embassy_time::Timer;
+use embedded_graphics::primitives::Rectangle;
+use heapless::String;
+
+mod peripherals;
+use peripherals::conf_peripherals;
+mod display;
+use display::display_handler;
+
+embassy_rp::bind_interrupts!(struct Irqs {
+    I2C1_IRQ => i2c::InterruptHandler<I2C1>;
+});
+
+static STRING: Mutex<ThreadModeRawMutex, String<25>> = Mutex::new(String::new());
+static LAST_TEXT_RECT: Mutex<ThreadModeRawMutex, RefCell<Option<Rectangle>>> =
+    Mutex::new(RefCell::new(None));
+
+#[embassy_executor::main]
+async fn main(_spawner: Spawner) {
+    let p = embassy_rp::init(Default::default());
+
+    STRING.lock().await.push_str("Press Del").unwrap();
+
+    // configure keyboard event handler
+    let mut config = i2c::Config::default();
+    config.frequency = 400_000;
+    let i2c1 = I2c::new_async(p.I2C1, p.PIN_7, p.PIN_6, Irqs, config);
+    conf_peripherals(i2c1).await;
+
+    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,
+    );
+
+    join(
+        async {
+            loop {
+                Timer::after_millis(20).await;
+                if let Some(key) = read_keyboard_fifo().await
+                    && key.state == KeyState::Pressed
+                {
+                    let mut string = STRING.lock().await;
+                    match key.key {
+                        KeyCode::Backspace => {
+                            string.pop().unwrap();
+                        }
+                        KeyCode::Del => {
+                            string.clear();
+                        }
+                        KeyCode::Char(c) => {
+                            string.push(c).unwrap();
+                        }
+                        _ => (),
+                    }
+                    DISPLAY_SIGNAL.signal(());
+                }
+            }
+        },
+        display_handler(spi1, p.PIN_13, p.PIN_14, p.PIN_15),
+    )
+    .await;
+}
+
+use abi::Syscall;
+
+#[no_mangle]
+pub extern "C" fn syscall_dispatch(call: *const Syscall) -> usize {
+    let call = unsafe { &*call };
+    match call {
+        Syscall::DrawPixel { x, y, color } => {
+            draw_pixel(*x, *y, *color);
+            0
+        }
+    }
+}

kernel/src/peripherals/keyboard.rs

@@ -0,0 +1,59 @@
+use crate::peripherals::PERIPHERAL_BUS;
+pub use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
+
+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() -> Option<KeyEvent> {
+    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()
+            {
+                return Some(KeyEvent {
+                    state: KeyState::from(event[0]),
+                    key: KeyCode::from(event[1]),
+                    mods: Modifiers::NONE,
+                });
+            }
+        }
+    }
+    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;
+}

kernel/src/peripherals/mod.rs

@@ -0,0 +1,98 @@
+//! 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, lazy_lock::LazyLock, mutex::Mutex};
+use embassy_time::Timer;
+
+pub mod keyboard;
+
+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;
+
+pub async fn conf_peripherals(i2c: I2CBUS) {
+    Timer::after(embassy_time::Duration::from_millis(100)).await;
+
+    PERIPHERAL_BUS.get().lock().await.replace(i2c);
+
+    configure_keyboard(200, 100).await;
+
+    // empty keys
+    while read_keyboard_fifo().await.is_some() {}
+
+    // 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]
+}