sawyer/picocalc-os-rs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: sawyer:fix-fb
Branches Tags
sawyer:main sawyer:gif sawyer:psram-alloc sawyer:fix-fb sawyer:userland-abi sawyer:usb-mass-storage sawyer:keyboard-writer sawyer:ui sawyer:working-display-colors sawyer:display+sim sawyer:display-framebuffer sawyer:mousefood
..
compare: sawyer:display+sim
Branches Tags
sawyer:gif sawyer:psram-alloc sawyer:main sawyer:fix-fb sawyer:userland-abi sawyer:usb-mass-storage sawyer:keyboard-writer sawyer:ui sawyer:working-display-colors sawyer:display+sim sawyer:display-framebuffer sawyer:mousefood

8 Commits
fix-fb ... display+si

Author SHA1 Message Date
sawyer bristol
530e1770f1 fix font size 2025-06-30 19:20:30 -06:00
sawyer bristol
7be20e9469 add status bar 2025-06-30 17:50:53 -06:00
sawyer bristol
0ad706dfc9 fix text alignment 2025-06-29 13:34:29 -06:00
sawyer bristol
073fa58121 split screen logic into seprate crate for testing 2025-06-29 08:44:17 -06:00
sawyer bristol
06a158623d wip text buffer for terminal 2025-06-27 21:23:38 -06:00
sawyer bristol
a687122696 fix bad display init 2025-06-27 18:41:01 -06:00
sawyer bristol
a42cfb6bc5 text wrong? 2025-06-27 15:29:08 -06:00
sawyer bristol
cf479cc00a diy framebuffer 2025-06-27 12:23:05 -06:00
34 changed files with 809 additions and 2981 deletions
Expand all files Collapse all files

880
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

14
Cargo.toml
View File

@@ -1,18 +1,10 @@
[workspace]
resolver = "3"
members = ["kernel", "abi", "shared", "user-apps/calculator"]
members = ["pico", "shared", "simulator"]
[profile.release]
debug = true
opt-level = "z"
lto = true
codegen-units = 1
[profile.release-binary]
inherits = "release"
lto = true
debug = false
opt-level = "s"
debug = 2
[profile.dev]
lto = true

12
abi/Cargo.toml
View File

@@ -1,12 +0,0 @@
[package]
name = "abi"
version = "0.1.0"
edition = "2024"
[dependencies]
embedded-graphics = "0.8.1"
shared = { path = "../shared" }
abi_sys = { path = "../abi_sys" }
talc = "4.4.3"
spin = "0.10.0"
embassy-time = "0.5.0"

74
abi/src/lib.rs
View File

@@ -1,74 +0,0 @@
#![no_std]
use abi_sys::draw_iter;
pub use abi_sys::{get_key, print, sleep};
pub use embassy_time;
pub use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
use talc::*;
static mut ARENA: [u8; 10000] = [0; 10000];
#[global_allocator]
static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
.lock();
pub mod display {
use crate::draw_iter;
use embedded_graphics::{
Pixel,
geometry::{Dimensions, Point},
pixelcolor::{Rgb565, RgbColor},
prelude::{DrawTarget, Size},
primitives::Rectangle,
};
pub const SCREEN_WIDTH: usize = 320;
pub const SCREEN_HEIGHT: usize = 320;
pub type Pixel565 = Pixel<Rgb565>;
pub struct Display;
impl Dimensions for Display {
fn bounding_box(&self) -> Rectangle {
Rectangle {
top_left: Point { x: 0, y: 0 },
size: Size {
width: SCREEN_WIDTH as u32,
height: SCREEN_HEIGHT as u32,
},
}
}
}
impl DrawTarget for Display {
type Color = Rgb565;
type Error = ();
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Pixel<Self::Color>>,
{
const BUF_SIZE: usize = 1024; // tune this for performance
let mut buf: [Pixel565; BUF_SIZE] = [Pixel(Point::new(0, 0), Rgb565::BLACK); BUF_SIZE];
let mut count = 0;
for p in pixels {
buf[count] = p;
count += 1;
if count == BUF_SIZE {
draw_iter(&buf[..count]);
count = 0;
}
}
if count > 0 {
draw_iter(&buf[..count]);
}
Ok(())
}
}
}

71
abi_sys/src/lib.rs
View File

@@ -1,71 +0,0 @@
#![no_std]
extern crate alloc;
use alloc::boxed::Box;
use core::pin::Pin;
pub use embedded_graphics::{
Pixel,
geometry::Point,
pixelcolor::{Rgb565, RgbColor},
};
use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers};
pub type EntryFn = fn() -> Pin<Box<dyn Future<Output = ()>>>;
#[unsafe(no_mangle)]
#[unsafe(link_section = ".user_reloc")]
pub static mut CALL_ABI_TABLE: [usize; CallAbiTable::COUNT] = [0; CallAbiTable::COUNT];
#[repr(usize)]
#[derive(Clone, Copy)]
pub enum CallAbiTable {
Print = 0,
Sleep = 1,
DrawIter = 2,
GetKey = 3,
}
impl CallAbiTable {
pub const COUNT: usize = 4;
}
pub type PrintAbi = extern "Rust" fn(msg: &str);
pub fn print(msg: &str) {
unsafe {
let ptr = CALL_ABI_TABLE[CallAbiTable::Print as usize];
let f: PrintAbi = core::mem::transmute(ptr);
f(msg);
}
}
pub type SleepAbi = extern "Rust" fn(ms: u64);
pub fn sleep(ms: u64) {
unsafe {
let ptr = CALL_ABI_TABLE[CallAbiTable::Sleep as usize];
let f: SleepAbi = core::mem::transmute(ptr);
f(ms);
}
}
pub type DrawIterAbi = extern "Rust" fn(pixels: &[Pixel<Rgb565>]);
pub fn draw_iter(pixels: &[Pixel<Rgb565>]) {
unsafe {
let ptr = CALL_ABI_TABLE[CallAbiTable::DrawIter as usize];
let f: DrawIterAbi = core::mem::transmute(ptr);
f(pixels);
}
}
pub type GetKeyAbi = extern "Rust" fn() -> Option<KeyEvent>;
pub fn get_key() -> Option<KeyEvent> {
unsafe {
let ptr = CALL_ABI_TABLE[CallAbiTable::GetKey as usize];
let f: GetKeyAbi = core::mem::transmute(ptr);
f()
}
}

4
justfile
View File

@@ -1,4 +0,0 @@
kernel: calculator
cargo run --bin kernel
calculator:
RUSTFLAGS="-C link-arg=--noinhibit-exec" cargo build --bin calculator --profile release-binary

46
kernel/src/abi.rs
View File

@@ -1,46 +0,0 @@
use core::{pin::Pin, time::Duration};
use abi_sys::{DrawIterAbi, GetKeyAbi, Pixel, PrintAbi, SleepAbi};
use alloc::boxed::Box;
use defmt::info;
use embassy_futures::block_on;
use embassy_rp::clocks::clk_sys_freq;
use embassy_time::Timer;
use embedded_graphics::{
Drawable,
draw_target::DrawTarget,
pixelcolor::Rgb565,
prelude::{Point, RgbColor, Size},
primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
};
use shared::keyboard::KeyEvent;
use crate::{KEY_CACHE, display::FRAMEBUFFER};
// ensure the abi and the kernel fn signatures are the same
const _: PrintAbi = print;
const _: SleepAbi = sleep;
const _: DrawIterAbi = draw_iter;
const _: GetKeyAbi = get_key;
pub extern "Rust" fn print(msg: &str) {
defmt::info!("{:?}", msg);
}
pub extern "Rust" fn sleep(ms: u64) {
let cycles_per_ms = clk_sys_freq() / 1000;
for _ in 0..ms {
for _ in 0..cycles_per_ms {
cortex_m::asm::nop();
}
}
}
// TODO: maybe return result
pub extern "Rust" fn draw_iter(pixels: &[Pixel<Rgb565>]) {
unsafe { FRAMEBUFFER.draw_iter(pixels.iter().copied()).unwrap() }
}
pub extern "Rust" fn get_key() -> Option<KeyEvent> {
unsafe { KEY_CACHE.dequeue() }
}

70
kernel/src/display.rs
View File

@@ -1,70 +0,0 @@
use crate::framebuffer::AtomicFrameBuffer;
use embassy_rp::{
Peri,
gpio::{Level, Output},
peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
spi::{Async, Spi},
};
use embassy_time::{Delay, Timer};
use embedded_graphics::{
draw_target::DrawTarget,
pixelcolor::{Rgb565, RgbColor},
prelude::Dimensions,
};
use embedded_hal_bus::spi::ExclusiveDevice;
use st7365p_lcd::ST7365P;
type DISPLAY = ST7365P<
ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
Output<'static>,
Output<'static>,
Delay,
>;
pub const SCREEN_WIDTH: usize = 320;
pub const SCREEN_HEIGHT: usize = 320;
pub static mut FRAMEBUFFER: AtomicFrameBuffer = AtomicFrameBuffer::new();
pub async fn init_display(
spi: Spi<'static, SPI1, Async>,
cs: Peri<'static, PIN_13>,
data: Peri<'static, PIN_14>,
reset: Peri<'static, PIN_15>,
) -> DISPLAY {
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,
);
display.init().await.unwrap();
display.set_custom_orientation(0x40).await.unwrap();
unsafe { FRAMEBUFFER.draw(&mut display).await.unwrap() }
display.set_on().await.unwrap();
display
}
pub fn clear_fb() {
let bounds = unsafe { FRAMEBUFFER.bounding_box() };
unsafe {
let _ = FRAMEBUFFER.fill_solid(&bounds, Rgb565::BLACK);
}
}
pub async fn display_handler(mut display: DISPLAY) {
loop {
unsafe {
FRAMEBUFFER
.partial_draw_batched(&mut display)
.await
.unwrap()
}
Timer::after_millis(32).await; // 30 fps
}
}

205
kernel/src/elf.rs
View File

@@ -1,205 +0,0 @@
#![allow(static_mut_refs)]
use crate::{
abi,
storage::{File, SDCARD},
};
use abi_sys::{CallAbiTable, EntryFn};
use alloc::{vec, vec::Vec};
use embedded_sdmmc::ShortFileName;
use goblin::{
elf::{
header::header32::Header,
program_header::program_header32::{PT_LOAD, ProgramHeader},
section_header::SHT_SYMTAB,
},
elf32::{section_header::SectionHeader, sym::Sym},
};
const ELF32_HDR_SIZE: usize = 52;
// userland ram region defined in memory.x
unsafe extern "C" {
static __userapp_start__: u8;
static __userapp_end__: u8;
}
pub async unsafe fn load_binary(name: &ShortFileName) -> Result<EntryFn, &str> {
let mut sd_lock = SDCARD.get().lock().await;
let sd = sd_lock.as_mut().unwrap();
let mut error = "";
let mut entry = 0;
let mut header_buf = [0; ELF32_HDR_SIZE];
sd.read_file(name, |mut file| {
file.read(&mut header_buf).unwrap();
let elf_header = Header::from_bytes(&header_buf);
let mut program_headers_buf = vec![0_u8; elf_header.e_phentsize as usize];
for i in 1..=elf_header.e_phnum {
file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32)
.unwrap();
file.read(&mut program_headers_buf).unwrap();
let ph = cast_phdr(&program_headers_buf);
if ph.p_type == PT_LOAD {
load_segment(&mut file, &ph).unwrap()
}
}
// MUST MATCH ABI EXACTLY
let entries: &[(CallAbiTable, usize)] = &[
(CallAbiTable::Print, abi::print as usize),
(CallAbiTable::Sleep, abi::sleep as usize),
(CallAbiTable::DrawIter, abi::draw_iter as usize),
(CallAbiTable::GetKey, abi::get_key as usize),
];
assert!(entries.len() == CallAbiTable::COUNT);
patch_abi(entries, &elf_header, &mut file).unwrap();
// TODO: dynamically search for abi table
entry = elf_header.e_entry as u32;
})
.await
.unwrap();
if entry != 0 {
Ok(unsafe { core::mem::transmute(entry) })
} else {
Err(error)
}
}
fn patch_abi(
entries: &[(CallAbiTable, usize)],
elf_header: &Header,
file: &mut File,
) -> Result<(), ()> {
for i in 1..=elf_header.e_shnum {
let sh = read_section(file, &elf_header, i.into());
// find the symbol table
if sh.sh_type == SHT_SYMTAB {
let mut symtab_buf = vec![0u8; sh.sh_size as usize];
file.seek_from_start(sh.sh_offset).unwrap();
file.read(&mut symtab_buf).unwrap();
// Cast buffer into symbols
let sym_count = sh.sh_size as usize / sh.sh_entsize as usize;
for i in 0..sym_count {
let sym_bytes =
&symtab_buf[i * sh.sh_entsize as usize..(i + 1) * sh.sh_entsize as usize];
let sym = cast_sym(sym_bytes);
let str_sh = read_section(file, &elf_header, sh.sh_link);
let mut name = Vec::new();
file.seek_from_start(str_sh.sh_offset + sym.st_name)
.unwrap();
loop {
let mut byte = [0u8; 1];
file.read(&mut byte).unwrap();
if byte[0] == 0 {
break;
}
name.push(byte[0]);
}
let symbol_name = core::str::from_utf8(&name).unwrap();
if symbol_name == "CALL_ABI_TABLE" {
let table_base = sym.st_value as *mut usize;
for &(abi_idx, func_ptr) in entries {
unsafe {
table_base.add(abi_idx as usize).write(func_ptr);
}
}
return Ok(());
}
}
}
}
Err(())
}
fn read_section(file: &mut File, elf_header: &Header, section: u32) -> SectionHeader {
let mut section_header_buf = vec![0_u8; elf_header.e_shentsize as usize];
file.seek_from_start(elf_header.e_shoff + (elf_header.e_shentsize as u32 * section))
.unwrap();
file.read(&mut section_header_buf).unwrap();
cast_shdr(&section_header_buf)
}
fn load_segment(file: &mut File, ph: &ProgramHeader) -> Result<(), ()> {
let dst_start = ph.p_vaddr as *mut u8;
let filesz = ph.p_filesz as usize;
let memsz = ph.p_memsz as usize;
let vaddr = ph.p_vaddr as usize;
let mut remaining = filesz;
let mut dst_ptr = dst_start;
let mut file_offset = ph.p_offset;
let seg_start = vaddr;
let seg_end = vaddr + memsz;
// Bounds check: make sure segment fits inside payload region
let user_start = unsafe { &__userapp_start__ as *const u8 as usize };
let user_end = unsafe { &__userapp_end__ as *const u8 as usize };
if seg_start < user_start || seg_end > user_end {
panic!(
"Segment out of bounds: {:x}..{:x} not within {:x}..{:x}",
seg_start, seg_end, user_start, user_end
);
}
// Buffer for chunked reads (512 bytes is typical SD sector size)
let mut buf = [0u8; 512];
while remaining > 0 {
let to_read = core::cmp::min(remaining, buf.len());
// Read chunk from file
file.seek_from_start(file_offset).unwrap();
file.read(&mut buf[..to_read]).unwrap();
unsafe {
// Copy chunk directly into destination memory
core::ptr::copy_nonoverlapping(buf.as_ptr(), dst_ptr, to_read);
dst_ptr = dst_ptr.add(to_read);
}
remaining -= to_read;
file_offset += to_read as u32;
}
// Zero BSS (memsz - filesz)
if memsz > filesz {
unsafe {
core::ptr::write_bytes(dst_ptr, 0, memsz - filesz);
}
}
Ok(())
}
fn cast_phdr(buf: &[u8]) -> ProgramHeader {
assert!(buf.len() >= core::mem::size_of::<ProgramHeader>());
unsafe { core::ptr::read(buf.as_ptr() as *const ProgramHeader) }
}
fn cast_shdr(buf: &[u8]) -> SectionHeader {
assert!(buf.len() >= core::mem::size_of::<SectionHeader>());
unsafe { core::ptr::read(buf.as_ptr() as *const SectionHeader) }
}
fn cast_sym(buf: &[u8]) -> Sym {
assert!(buf.len() >= core::mem::size_of::<Sym>());
unsafe { core::ptr::read(buf.as_ptr() as *const Sym) }
}

432
kernel/src/framebuffer.rs
View File

@@ -1,432 +0,0 @@
use crate::display::{SCREEN_HEIGHT, SCREEN_WIDTH};
use core::sync::atomic::{AtomicBool, Ordering};
use embassy_sync::lazy_lock::LazyLock;
use embedded_graphics::{
draw_target::DrawTarget,
pixelcolor::{
Rgb565,
raw::{RawData, RawU16},
},
prelude::*,
primitives::Rectangle,
};
use embedded_hal_2::digital::OutputPin;
use embedded_hal_async::{delay::DelayNs, spi::SpiDevice};
use heapless::Vec;
use st7365p_lcd::{FrameBuffer, ST7365P};
pub const TILE_SIZE: usize = 16; // 16x16 tile
pub const TILE_COUNT: usize = (SCREEN_WIDTH / TILE_SIZE) * (SCREEN_HEIGHT / TILE_SIZE); // 400 tiles
// Group of tiles for batching
pub const MAX_META_TILES: usize = SCREEN_WIDTH / TILE_SIZE; // max number of meta tiles in buffer
type MetaTileVec = heapless::Vec<Rectangle, { TILE_COUNT / MAX_META_TILES }>;
const SIZE: usize = SCREEN_HEIGHT * SCREEN_WIDTH;
static mut BUFFER: [u16; SIZE] = [0; SIZE];
static mut DIRTY_TILES: LazyLock<Vec<AtomicBool, TILE_COUNT>> = LazyLock::new(|| {
let mut tiles = Vec::new();
for _ in 0..TILE_COUNT {
tiles.push(AtomicBool::new(true)).unwrap();
}
tiles
});
#[allow(dead_code)]
pub struct AtomicFrameBuffer;
impl AtomicFrameBuffer {
pub const fn new() -> Self {
Self
}
fn mark_tiles_dirty(&mut self, rect: Rectangle) {
let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
let start_tx = (rect.top_left.x as usize) / TILE_SIZE;
let end_tx = ((rect.top_left.x + rect.size.width as i32 - 1) as usize) / TILE_SIZE;
let start_ty = (rect.top_left.y as usize) / TILE_SIZE;
let end_ty = ((rect.top_left.y + rect.size.height as i32 - 1) as usize) / TILE_SIZE;
for ty in start_ty..=end_ty {
for tx in start_tx..=end_tx {
let tile_idx = ty * tiles_x + tx;
unsafe { DIRTY_TILES.get_mut()[tile_idx].store(true, Ordering::Relaxed) };
}
}
}
fn set_pixel(&mut self, x: u16, y: u16, color: u16) -> Result<(), ()> {
unsafe { BUFFER[(y as usize * SCREEN_WIDTH) + x as usize] = color };
Ok(())
}
fn set_pixels_buffered<P: IntoIterator<Item = u16>>(
&mut self,
sx: u16,
sy: u16,
ex: u16,
ey: u16,
colors: P,
) -> Result<(), ()> {
if sx >= self.size().width as u16 - 1
|| ex >= self.size().width as u16 - 1
|| sy >= self.size().height as u16 - 1
|| ey >= self.size().height as u16 - 1
{
return Err(()); // Bounds check
}
let mut color_iter = colors.into_iter();
for y in sy..=ey {
for x in sx..=ex {
if let Some(color) = color_iter.next() {
unsafe { BUFFER[(y as usize * SCREEN_WIDTH) + x as usize] = color };
} else {
return Err(()); // Not enough data
}
}
}
// Optional: check that we consumed *exactly* the right amount
if color_iter.next().is_some() {
return Err(()); // Too much data
}
Ok(())
}
// walk the dirty tiles and mark groups of tiles(meta-tiles) for batched updates
fn find_meta_tiles(&mut self, tiles_x: usize, tiles_y: usize) -> MetaTileVec {
let mut meta_tiles: MetaTileVec = Vec::new();
for ty in 0..tiles_y {
let mut tx = 0;
while tx < tiles_x {
let idx = ty * tiles_x + tx;
if !unsafe { DIRTY_TILES.get()[idx].load(Ordering::Acquire) } {
tx += 1;
continue;
}
// Start meta-tile at this tile
let mut width_tiles = 1;
let height_tiles = 1;
// Grow horizontally, but keep under MAX_TILES_PER_METATILE
while tx + width_tiles < tiles_x
&& unsafe {
DIRTY_TILES.get()[ty * tiles_x + tx + width_tiles].load(Ordering::Relaxed)
}
&& (width_tiles + height_tiles) <= MAX_META_TILES
{
width_tiles += 1;
}
// TODO: for simplicity, skipped vertical growth
for x_off in 0..width_tiles {
unsafe {
DIRTY_TILES.get()[ty * tiles_x + tx + x_off]
.store(false, Ordering::Release);
};
}
// new meta-tile pos
let rect = Rectangle::new(
Point::new((tx * TILE_SIZE) as i32, (ty * TILE_SIZE) as i32),
Size::new(
(width_tiles * TILE_SIZE) as u32,
(height_tiles * TILE_SIZE) as u32,
),
);
if meta_tiles.push(rect).is_err() {
return meta_tiles;
};
tx += width_tiles;
}
}
meta_tiles
}
/// Sends the entire framebuffer to the display
pub async fn draw<SPI, DC, RST, DELAY: DelayNs>(
&mut self,
display: &mut ST7365P<SPI, DC, RST, DELAY>,
) -> Result<(), ()>
where
SPI: SpiDevice,
DC: OutputPin,
RST: OutputPin,
{
display
.set_pixels_buffered(
0,
0,
self.size().width as u16 - 1,
self.size().height as u16 - 1,
unsafe { &BUFFER },
)
.await?;
unsafe {
for tile in DIRTY_TILES.get_mut().iter() {
tile.store(false, Ordering::Release);
}
};
Ok(())
}
/// Sends only dirty tiles (16x16px) individually to the display without batching
pub async fn partial_draw<SPI, DC, RST, DELAY: DelayNs>(
&mut self,
display: &mut ST7365P<SPI, DC, RST, DELAY>,
) -> Result<(), ()>
where
SPI: SpiDevice,
DC: OutputPin,
RST: OutputPin,
{
if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
let mut tile_buffer = [0u16; TILE_SIZE * TILE_SIZE];
for ty in 0..tiles_y {
for tx in 0..tiles_x {
if unsafe { !DIRTY_TILES.get()[ty * tiles_x + tx].load(Ordering::Acquire) } {
continue;
}
let x = tx * TILE_SIZE;
let y = ty * TILE_SIZE;
// Copy pixels for the tile into tile_buffer
for row in 0..TILE_SIZE {
for col in 0..TILE_SIZE {
let actual_x = x + col;
let actual_y = y + row;
if actual_x < SCREEN_WIDTH && actual_y < SCREEN_HEIGHT {
let idx = actual_y * SCREEN_WIDTH + actual_x;
tile_buffer[row * TILE_SIZE + col] = unsafe { BUFFER[idx] };
} else {
// Out of bounds, fill with zero (or background)
tile_buffer[row * TILE_SIZE + col] = 0;
}
}
}
// Send the tile's pixel data to the display
display
.set_pixels_buffered(
x as u16,
y as u16,
(x + TILE_SIZE - 1).min(SCREEN_WIDTH - 1) as u16,
(y + TILE_SIZE - 1).min(SCREEN_HEIGHT - 1) as u16,
&tile_buffer,
)
.await?;
// Mark tile as clean
unsafe {
DIRTY_TILES.get_mut()[ty * tiles_x + tx].store(false, Ordering::Release)
};
}
}
}
Ok(())
}
/// Sends only dirty tiles (16x16px) in batches to the display
pub async fn partial_draw_batched<SPI, DC, RST, DELAY>(
&mut self,
display: &mut ST7365P<SPI, DC, RST, DELAY>,
) -> Result<(), ()>
where
SPI: SpiDevice,
DC: OutputPin,
RST: OutputPin,
DELAY: DelayNs,
{
if unsafe { DIRTY_TILES.get().iter().any(|p| p.load(Ordering::Acquire)) } {
let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE;
let tiles_y = (SCREEN_HEIGHT + TILE_SIZE - 1) / TILE_SIZE;
let meta_tiles = self.find_meta_tiles(tiles_x, tiles_y);
// buffer for copying meta tiles before sending to display
let mut pixel_buffer: heapless::Vec<u16, { MAX_META_TILES * TILE_SIZE * TILE_SIZE }> =
Vec::new();
for rect in meta_tiles {
let rect_width = rect.size.width as usize;
let rect_height = rect.size.height as usize;
let rect_x = rect.top_left.x as usize;
let rect_y = rect.top_left.y as usize;
pixel_buffer.clear();
for row in 0..rect_height {
let y = rect_y + row;
let start = y * SCREEN_WIDTH + rect_x;
let end = start + rect_width;
// Safe: we guarantee buffer will not exceed MAX_META_TILE_PIXELS
pixel_buffer
.extend_from_slice(unsafe { &BUFFER[start..end] })
.unwrap();
}
display
.set_pixels_buffered(
rect_x as u16,
rect_y as u16,
(rect_x + rect_width - 1) as u16,
(rect_y + rect_height - 1) as u16,
&pixel_buffer,
)
.await?;
// walk the meta-tile and set as clean
let start_tx = rect_x / TILE_SIZE;
let start_ty = rect_y / TILE_SIZE;
let end_tx = (rect_x + rect_width - 1) / TILE_SIZE;
let end_ty = (rect_y + rect_height - 1) / TILE_SIZE;
for ty in start_ty..=end_ty {
for tx in start_tx..=end_tx {
let tile_idx = ty * tiles_x + tx;
unsafe { DIRTY_TILES.get_mut()[tile_idx].store(false, Ordering::Release) };
}
}
}
}
Ok(())
}
}
impl DrawTarget for AtomicFrameBuffer {
type Error = ();
type Color = Rgb565;
fn draw_iter<I>(&mut self, pixels: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Pixel<Self::Color>>,
{
let mut dirty_rect: Option<Rectangle> = None;
for Pixel(coord, color) in pixels {
if coord.x >= 0 && coord.y >= 0 {
let x = coord.x as i32;
let y = coord.y as i32;
if (x as usize) < SCREEN_WIDTH && (y as usize) < SCREEN_HEIGHT {
unsafe {
BUFFER[(y as usize) * SCREEN_WIDTH + (x as usize)] =
RawU16::from(color).into_inner()
};
if let Some(ref mut rect) = dirty_rect {
rect.top_left.x = rect.top_left.x.min(x);
rect.top_left.y = rect.top_left.y.min(y);
let max_x = (rect.top_left.x + rect.size.width as i32 - 1).max(x);
let max_y = (rect.top_left.y + rect.size.height as i32 - 1).max(y);
rect.size.width = (max_x - rect.top_left.x + 1) as u32;
rect.size.height = (max_y - rect.top_left.y + 1) as u32;
} else {
dirty_rect = Some(Rectangle::new(Point::new(x, y), Size::new(1, 1)));
}
}
}
}
if let Some(rect) = dirty_rect {
self.mark_tiles_dirty(rect);
}
Ok(())
}
fn fill_contiguous<I>(&mut self, area: &Rectangle, colors: I) -> Result<(), Self::Error>
where
I: IntoIterator<Item = Self::Color>,
{
let drawable_area = area.intersection(&Rectangle::new(Point::zero(), self.size()));
if drawable_area.size != Size::zero() {
// We assume that `colors` iterator is in row-major order for the original `area`
// So we must skip rows/pixels that are clipped
let area_width = area.size.width;
let area_height = area.size.height;
let mut colors = colors.into_iter();
for y in 0..area_height {
for x in 0..area_width {
let p = area.top_left + Point::new(x as i32, y as i32);
if drawable_area.contains(p) {
if let Some(color) = colors.next() {
self.set_pixel(
p.x as u16,
p.y as u16,
RawU16::from(color).into_inner(),
)?;
} else {
break;
}
} else {
// Still need to consume the color even if not used!
let _ = colors.next();
}
}
}
self.mark_tiles_dirty(*area);
}
Ok(())
}
fn fill_solid(&mut self, area: &Rectangle, color: Self::Color) -> Result<(), Self::Error> {
self.fill_contiguous(
area,
core::iter::repeat(color).take((self.size().width * self.size().height) as usize),
)
}
fn clear(&mut self, color: Self::Color) -> Result<(), Self::Error> {
self.set_pixels_buffered(
0,
0,
self.size().width as u16 - 1,
self.size().height as u16 - 1,
core::iter::repeat(RawU16::from(color).into_inner())
.take((self.size().width * self.size().height) as usize),
)?;
unsafe {
for tile in DIRTY_TILES.get_mut().iter() {
tile.store(true, Ordering::Relaxed);
}
}
Ok(())
}
}
impl OriginDimensions for AtomicFrameBuffer {
fn size(&self) -> Size {
Size::new(SCREEN_WIDTH as u32, SCREEN_HEIGHT as u32)
}
}

268
kernel/src/main.rs
View File

@@ -1,268 +0,0 @@
#![feature(impl_trait_in_assoc_type)]
#![feature(type_alias_impl_trait)]
#![feature(ascii_char)]
#![cfg_attr(not(test), no_std)]
#![cfg_attr(not(test), no_main)]
#![allow(static_mut_refs)]
extern crate alloc;
mod abi;
mod display;
mod elf;
mod framebuffer;
mod peripherals;
mod scsi;
mod storage;
mod ui;
mod usb;
mod utils;
use crate::{
display::{FRAMEBUFFER, clear_fb, display_handler, init_display},
elf::load_binary,
peripherals::{
conf_peripherals,
keyboard::{KeyCode, KeyState, read_keyboard_fifo},
},
storage::{SDCARD, SdCard},
ui::{SELECTIONS, ui_handler},
usb::usb_handler,
};
use abi_sys::EntryFn;
use {defmt_rtt as _, panic_probe as _};
use assign_resources::assign_resources;
use defmt::unwrap;
use embassy_executor::{Executor, Spawner};
use embassy_futures::join::{join, join3, join4, join5};
use embassy_rp::{
Peri,
gpio::{Input, Level, Output, Pull},
i2c::{self, I2c},
multicore::{Stack, spawn_core1},
peripherals::{
DMA_CH0, DMA_CH1, I2C1, PIN_6, PIN_7, PIN_10, PIN_11, PIN_12, PIN_13, PIN_14, PIN_15,
PIN_16, PIN_17, PIN_18, PIN_19, PIN_22, SPI0, SPI1, USB,
},
spi::{self, Spi},
usb as embassy_rp_usb,
};
use embassy_sync::{
blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, mutex::Mutex, signal::Signal,
};
use embassy_time::{Delay, Timer};
use embedded_hal_bus::spi::ExclusiveDevice;
use embedded_sdmmc::SdCard as SdmmcSdCard;
use heapless::spsc::Queue;
use shared::keyboard::KeyEvent;
use static_cell::StaticCell;
use talc::*;
embassy_rp::bind_interrupts!(struct Irqs {
I2C1_IRQ => i2c::InterruptHandler<I2C1>;
USBCTRL_IRQ => embassy_rp_usb::InterruptHandler<USB>;
});
static mut CORE1_STACK: Stack<16384> = Stack::new();
static EXECUTOR0: StaticCell<Executor> = StaticCell::new();
static EXECUTOR1: StaticCell<Executor> = StaticCell::new();
static mut ARENA: [u8; 10 * 1024] = [0; 10 * 1024];
#[global_allocator]
static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
Talc::new(unsafe { ClaimOnOom::new(Span::from_array(core::ptr::addr_of!(ARENA).cast_mut())) })
.lock();
static TASK_STATE: Mutex<CriticalSectionRawMutex, TaskState> = Mutex::new(TaskState::Ui);
static TASK_STATE_CHANGED: Signal<CriticalSectionRawMutex, ()> = Signal::new();
#[derive(Copy, Clone, PartialEq)]
enum TaskState {
Ui,
Kernel,
}
#[embassy_executor::main]
async fn main(_spawner: Spawner) {
let p = embassy_rp::init(Default::default());
spawn_core1(
p.CORE1,
unsafe { &mut *core::ptr::addr_of_mut!(CORE1_STACK) },
move || {
let executor1 = EXECUTOR1.init(Executor::new());
executor1.run(|spawner| unwrap!(spawner.spawn(userland_task())));
},
);
let display = Display {
spi: p.SPI1,
clk: p.PIN_10,
mosi: p.PIN_11,
miso: p.PIN_12,
dma1: p.DMA_CH0,
dma2: p.DMA_CH1,
cs: p.PIN_13,
data: p.PIN_14,
reset: p.PIN_15,
};
let sd = Sd {
spi: p.SPI0,
clk: p.PIN_18,
mosi: p.PIN_19,
miso: p.PIN_16,
cs: p.PIN_17,
det: p.PIN_22,
};
let mcu = Mcu {
i2c: p.I2C1,
clk: p.PIN_7,
data: p.PIN_6,
};
let executor0 = EXECUTOR0.init(Executor::new());
executor0.run(|spawner| unwrap!(spawner.spawn(kernel_task(display, sd, mcu, p.USB))));
}
// One-slot channel to pass EntryFn from core1
static BINARY_CH: Channel<CriticalSectionRawMutex, EntryFn, 1> = Channel::new();
// runs dynamically loaded elf files
#[embassy_executor::task]
async fn userland_task() {
let recv = BINARY_CH.receiver();
loop {
let entry = recv.receive().await;
defmt::info!("Got Entry");
// disable kernel ui
{
let mut state = TASK_STATE.lock().await;
*state = TaskState::Kernel;
}
// clear_fb();
defmt::info!("Executing Binary");
entry().await;
// enable kernel ui
{
let mut state = TASK_STATE.lock().await;
*state = TaskState::Ui;
}
}
}
struct Display {
spi: Peri<'static, SPI1>,
clk: Peri<'static, PIN_10>,
mosi: Peri<'static, PIN_11>,
miso: Peri<'static, PIN_12>,
dma1: Peri<'static, DMA_CH0>,
dma2: Peri<'static, DMA_CH1>,
cs: Peri<'static, PIN_13>,
data: Peri<'static, PIN_14>,
reset: Peri<'static, PIN_15>,
}
struct Sd {
spi: Peri<'static, SPI0>,
clk: Peri<'static, PIN_18>,
mosi: Peri<'static, PIN_19>,
miso: Peri<'static, PIN_16>,
cs: Peri<'static, PIN_17>,
det: Peri<'static, PIN_22>,
}
struct Mcu {
i2c: Peri<'static, I2C1>,
clk: Peri<'static, PIN_7>,
data: Peri<'static, PIN_6>,
}
#[embassy_executor::task]
async fn kernel_task(display: Display, sd: Sd, mcu: Mcu, usb: Peri<'static, USB>) {
// MCU i2c bus for peripherals
let mut config = i2c::Config::default();
config.frequency = 400_000;
let i2c1 = I2c::new_async(mcu.i2c, mcu.clk, mcu.data, Irqs, config);
conf_peripherals(i2c1).await;
Timer::after_millis(250).await;
let mut config = spi::Config::default();
config.frequency = 16_000_000;
let spi = Spi::new(
display.spi,
display.clk,
display.mosi,
display.miso,
display.dma1,
display.dma2,
config,
);
let display = init_display(spi, display.cs, display.data, display.reset).await;
let display_fut = display_handler(display);
let ui_fut = ui_handler();
let binary_search_fut = async {
loop {
{
let mut guard = SDCARD.get().lock().await;
if let Some(sd) = guard.as_mut() {
let files = sd.list_files_by_extension(".bin").unwrap();
let mut select = SELECTIONS.lock().await;
if select.selections != files {
select.selections = files;
select.reset();
}
}
}
Timer::after_secs(5).await;
}
};
{
let mut config = spi::Config::default();
config.frequency = 400_000;
let spi = Spi::new_blocking(sd.spi, sd.clk, sd.mosi, sd.miso, config.clone());
let cs = Output::new(sd.cs, Level::High);
let det = Input::new(sd.det, Pull::None);
let device = ExclusiveDevice::new(spi, cs, Delay).unwrap();
let sdcard = SdmmcSdCard::new(device, Delay);
config.frequency = 32_000_000;
sdcard.spi(|dev| dev.bus_mut().set_config(&config));
SDCARD.get().lock().await.replace(SdCard::new(sdcard, det));
};
let usb = embassy_rp_usb::Driver::new(usb, Irqs);
let usb_fut = usb_handler(usb);
let key_abi_fut = async {
loop {
Timer::after_millis(100).await;
get_keys().await
}
};
join5(display_fut, ui_fut, usb_fut, binary_search_fut, key_abi_fut).await;
}
static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();
async fn get_keys() {
if let Some(event) = read_keyboard_fifo().await {
if let KeyState::Pressed = event.state {
unsafe {
let _ = KEY_CACHE.enqueue(event);
}
}
}
}

59
kernel/src/peripherals/keyboard.rs
View File

@@ -1,59 +0,0 @@
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;
}

320
kernel/src/scsi/mod.rs
View File

@@ -1,320 +0,0 @@
use crate::format;
use embassy_usb::driver::{Driver, EndpointIn, EndpointOut};
use embassy_usb::types::StringIndex;
use embassy_usb::{Builder, Config};
use embedded_sdmmc::{Block, BlockIdx};
use heapless::Vec;
mod scsi_types;
use scsi_types::*;
use crate::storage::{SDCARD, SdCard};
const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
pub struct MassStorageClass<'d, D: Driver<'d>> {
bulk_out: D::EndpointOut,
bulk_in: D::EndpointIn,
}
impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> {
pub fn new(builder: &mut Builder<'d, D>) -> Self {
let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class
let mut interface = function.interface();
let mut alt = interface.alt_setting(0x08, SUBCLASS_SCSI, 0x50, None);
let bulk_out = alt.endpoint_bulk_out(None, BULK_ENDPOINT_PACKET_SIZE as u16);
let bulk_in = alt.endpoint_bulk_in(None, BULK_ENDPOINT_PACKET_SIZE as u16);
Self { bulk_out, bulk_in }
}
pub async fn poll(&mut self) {
loop {
let mut cbw_buf = [0u8; 31];
if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await {
if n == 31 {
if let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) {
// TODO: validate cbw
if self.handle_command(&cbw.CBWCB).await.is_ok() {
self.send_csw_success(cbw.dCBWTag).await
} else {
self.send_csw_fail(cbw.dCBWTag).await
}
}
}
}
}
}
async fn handle_command(&mut self, cbw: &[u8]) -> Result<(), ()> {
let mut response: Vec<u8, BULK_ENDPOINT_PACKET_SIZE> = Vec::new();
let mut block = [Block::new(); 1];
match parse_cb(cbw) {
ScsiCommand::Unknown => {
#[cfg(feature = "defmt")]
defmt::warn!("Got unexpected scsi command: {}", cbw);
Err(())
}
ScsiCommand::Inquiry {
evpd,
page_code,
alloc_len,
} => {
if !evpd {
response.push(0x00).map_err(|_| ())?; // Direct-access block device
response.push(0x80).map_err(|_| ())?; // Removable
response.push(0x05).map_err(|_| ())?; // SPC-3 compliance
response.push(0x02).map_err(|_| ())?; // Response data format
response.push(0x00).map_err(|_| ())?; // Additional length - edited later
response.push(0x00).map_err(|_| ())?; // FLAGS
response.push(0x00).map_err(|_| ())?; // FLAGS
response.push(0).map_err(|_| ())?; // FLAGS
assert!(response.len() == 8);
let vendor = b"LEGTCMPR";
assert!(vendor.len() == 8);
response.extend_from_slice(vendor)?;
let product = b"Pico Calc Sdcard";
assert!(product.len() == 16);
response.extend_from_slice(product)?;
let version = b"1.00";
assert!(version.len() == 4);
response.extend_from_slice(version)?; // 4-byte firmware version
let addl_len = response.len() - 5;
response[4] = addl_len as u8;
assert!(response.len() == 36);
} else {
match page_code {
0x00 => {
response
.extend_from_slice(&[
0x00, // Peripheral Qualifier + Peripheral Device Type (0x00 = Direct-access block device)
0x00, // Page Code (same as requested: 0x00)
0x00, 0x03, // Page Length: 3 bytes follow
0x00, // Supported VPD Page: 0x00 (this one — the "Supported VPD Pages" page itself)
0x80, // Supported VPD Page: 0x80 (Unit Serial Number)
0x83, // Supported VPD Page: 0x83 (Device Identification)
])
.map_err(|_| ())?
}
0x80 => {
let serial = b"Pico Calc";
response.extend_from_slice(&[
0x00, // Peripheral Qualifier & Device Type
0x80, // Page Code = 0x80 (Unit Serial Number)
0x00, // Reserved
serial.len() as u8,
])?;
response.extend_from_slice(serial)?;
}
0x83 => {
let id = b"SdCard";
response.extend_from_slice(&[
0x00,
0x83, // Page code
0x00,
(4 + id.len()) as u8, // Length
0x02, // ASCII identifier
0x01, // Identifier type
0x00, // Reserved
id.len() as u8,
])?;
response.extend_from_slice(id)?;
}
_ => (),
}
};
let len = core::cmp::min(alloc_len as usize, response.len());
self.bulk_in.write(&response[..len]).await.map_err(|_| ())
}
ScsiCommand::TestUnitReady => {
let guard = SDCARD.get().lock().await;
let sdcard = guard.as_ref().unwrap();
if sdcard.is_attached() {
Ok(())
} else {
Err(())
}
}
ScsiCommand::RequestSense { desc, alloc_len } => Ok(()),
ScsiCommand::ModeSense6 {
dbd,
page_control,
page_code,
subpage_code,
alloc_len,
} => {
// DBD=0, no block descriptors; total length = 4
let response = [
0x03, // Mode data length (excluding this byte): 3
0x00, // Medium type
0x00, // Device-specific parameter
0x00, // Block descriptor length = 0 (DBD = 1)
];
let len = alloc_len.min(response.len() as u8) as usize;
self.bulk_in.write(&response[..len]).await.map_err(|_| ())
}
ScsiCommand::ModeSense10 {
dbd,
page_control,
page_code,
subpage_code,
alloc_len,
} => {
let response = [
0x00, 0x06, // Mode data length = 6
0x00, // Medium type
0x00, // Device-specific parameter
0x00, 0x00, // Reserved
0x00, 0x00, // Block descriptor length = 0
];
let len = alloc_len.min(response.len() as u16) as usize;
self.bulk_in.write(&response[..len]).await.map_err(|_| ())
}
ScsiCommand::ReadCapacity10 => {
let guard = SDCARD.get().lock().await;
let sdcard = guard.as_ref().unwrap();
let block_size = SdCard::BLOCK_SIZE as u64;
let total_blocks = sdcard.size() / block_size;
let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
response.extend_from_slice(&(last_lba as u32).to_be_bytes())?;
response.extend_from_slice(&(block_size as u32).to_be_bytes())?;
self.bulk_in.write(&response).await.map_err(|_| ())
}
ScsiCommand::ReadCapacity16 { alloc_len } => {
let guard = SDCARD.get().lock().await;
let sdcard = guard.as_ref().unwrap();
let block_size = SdCard::BLOCK_SIZE as u64;
let total_blocks = sdcard.size() / block_size;
let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
response.extend_from_slice(&last_lba.to_be_bytes())?; // 8 bytes last LBA
response.extend_from_slice(&(block_size as u32).to_be_bytes())?; // 4 bytes block length
response.extend_from_slice(&[0u8; 20])?; // 20 reserved bytes zeroed
let len = alloc_len.min(response.len() as u32) as usize;
self.bulk_in.write(&response[..len]).await.map_err(|_| ())
}
ScsiCommand::Read { lba, len } => {
let guard = SDCARD.get().lock().await;
let sdcard = guard.as_ref().unwrap();
for i in 0..len {
let block_idx = BlockIdx(lba as u32 + i as u32);
sdcard.read_blocks(&mut block, block_idx)?;
for chunk in block[0].contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) {
self.bulk_in.write(chunk).await.map_err(|_| ())?;
}
}
Ok(())
}
ScsiCommand::Write { lba, len } => {
let guard = SDCARD.get().lock().await;
let sdcard = guard.as_ref().unwrap();
for i in 0..len {
let block_idx = BlockIdx(lba as u32 + i as u32);
for chunk in block[0]
.contents
.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into())
{
self.bulk_out.read(chunk).await.map_err(|_| ())?;
}
sdcard.write_blocks(&mut block, block_idx)?;
}
Ok(())
}
ScsiCommand::ReadFormatCapacities { alloc_len } => {
let guard = SDCARD.get().lock().await;
let sdcard = guard.as_ref().unwrap();
let block_size = SdCard::BLOCK_SIZE as u32;
let num_blocks = (sdcard.size() / block_size as u64) as u32;
let mut response = [0u8; 12];
// Capacity List Length (8 bytes follows)
response[3] = 8;
// Descriptor
response[4..8].copy_from_slice(&num_blocks.to_be_bytes());
response[8] = 0x03; // formatted media
response[9..12].copy_from_slice(&block_size.to_be_bytes()[1..4]); // only 3 bytes
let response_len = alloc_len.min(response.len() as u16) as usize;
self.bulk_in
.write(&response[..response_len])
.await
.map_err(|_| ())
}
ScsiCommand::PreventAllowMediumRemoval { prevent: _prevent } => Ok(()),
ScsiCommand::StartStopUnit { start, load_eject } => Ok(()),
}
}
pub async fn send_csw_success(&mut self, tag: u32) {
self.send_csw(tag, 0x00, 0).await;
}
pub async fn send_csw_fail(&mut self, tag: u32) {
defmt::error!("Command Failed");
self.send_csw(tag, 0x01, 0).await; // 0x01 = Command Failed
}
pub async fn send_csw(&mut self, tag: u32, status: u8, residue: u32) {
let mut csw = [0u8; 13];
csw[0..4].copy_from_slice(&0x53425355u32.to_le_bytes()); // Signature "USBS"
csw[4..8].copy_from_slice(&tag.to_le_bytes());
csw[8..12].copy_from_slice(&residue.to_le_bytes());
csw[12] = status;
let _ = self.bulk_in.write(&csw).await;
}
}
#[repr(C, packed)]
struct CommandBlockWrapper {
dCBWSignature: u32,
dCBWTag: u32,
dCBWDataTransferLength: u32,
bmCBWFlags: u8,
bCBWLUN: u8,
bCBWCBLength: u8,
CBWCB: [u8; 16],
}
impl CommandBlockWrapper {
fn parse(buf: &[u8]) -> Option<Self> {
if buf.len() < 31 {
return None;
}
let dCBWSignature = u32::from_le_bytes(buf[0..4].try_into().ok()?);
if dCBWSignature != 0x43425355 {
return None; // invalid signature
}
Some(Self {
dCBWSignature,
dCBWTag: u32::from_le_bytes(buf[4..8].try_into().ok()?),
dCBWDataTransferLength: u32::from_le_bytes(buf[8..12].try_into().ok()?),
bmCBWFlags: buf[12],
bCBWLUN: buf[13],
bCBWCBLength: buf[14],
CBWCB: buf[15..31].try_into().ok()?,
})
}
}

164
kernel/src/scsi/scsi_types.rs
View File

@@ -1,164 +0,0 @@
use num_enum::TryFromPrimitive;
#[derive(Debug, Clone, Copy)]
pub enum ScsiError {
NotReady,
}
/// THE CODE BELOW ORIGINATES FROM: https://github.com/apohrebniak/usbd-storage/blob/master/usbd-storage/src/subclass/scsi.rs
/// SCSI device subclass code
pub const SUBCLASS_SCSI: u8 = 0x06; // SCSI Transparent command set
/* SCSI codes */
/* SPC */
const TEST_UNIT_READY: u8 = 0x00;
const REQUEST_SENSE: u8 = 0x03;
const INQUIRY: u8 = 0x12;
const MODE_SENSE_6: u8 = 0x1A;
const MODE_SENSE_10: u8 = 0x5A;
/* SBC */
const READ_10: u8 = 0x28;
const READ_16: u8 = 0x88;
const READ_CAPACITY_10: u8 = 0x25;
const READ_CAPACITY_16: u8 = 0x9E;
const WRITE_10: u8 = 0x2A;
/* MMC */
const READ_FORMAT_CAPACITIES: u8 = 0x23;
const PREVENT_ALLOW_MEDIUM_REMOVAL: u8 = 0x1E;
const START_STOP_UNIT: u8 = 0x1B;
/// SCSI command
///
/// Refer to specifications (SPC,SAM,SBC,MMC,etc.)
#[derive(Copy, Clone, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[non_exhaustive]
pub enum ScsiCommand {
Unknown,
/* SPC */
Inquiry {
evpd: bool,
page_code: u8,
alloc_len: u16,
},
TestUnitReady,
RequestSense {
desc: bool,
alloc_len: u8,
},
ModeSense6 {
dbd: bool,
page_control: PageControl,
page_code: u8,
subpage_code: u8,
alloc_len: u8,
},
ModeSense10 {
dbd: bool,
page_control: PageControl,
page_code: u8,
subpage_code: u8,
alloc_len: u16,
},
/* SBC */
ReadCapacity10,
ReadCapacity16 {
alloc_len: u32,
},
Read {
lba: u64,
len: u64,
},
Write {
lba: u64,
len: u64,
},
/* MMC */
ReadFormatCapacities {
alloc_len: u16,
},
PreventAllowMediumRemoval {
prevent: bool,
},
StartStopUnit {
start: bool,
load_eject: bool,
},
}
#[repr(u8)]
#[derive(Copy, Clone, Debug, TryFromPrimitive)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum PageControl {
CurrentValues = 0b00,
ChangeableValues = 0b01,
DefaultValues = 0b10,
SavedValues = 0b11,
}
#[allow(dead_code)]
pub fn parse_cb(cb: &[u8]) -> ScsiCommand {
match cb[0] {
TEST_UNIT_READY => ScsiCommand::TestUnitReady,
INQUIRY => ScsiCommand::Inquiry {
evpd: (cb[1] & 0b00000001) != 0,
page_code: cb[2],
alloc_len: u16::from_be_bytes([cb[3], cb[4]]),
},
REQUEST_SENSE => ScsiCommand::RequestSense {
desc: (cb[1] & 0b00000001) != 0,
alloc_len: cb[4],
},
READ_CAPACITY_10 => ScsiCommand::ReadCapacity10,
READ_CAPACITY_16 => ScsiCommand::ReadCapacity16 {
alloc_len: u32::from_be_bytes([cb[10], cb[11], cb[12], cb[13]]),
},
READ_10 => ScsiCommand::Read {
lba: u32::from_be_bytes([cb[2], cb[3], cb[4], cb[5]]) as u64,
len: u16::from_be_bytes([cb[7], cb[8]]) as u64,
},
READ_16 => ScsiCommand::Read {
lba: u64::from_be_bytes((&cb[2..10]).try_into().unwrap()),
len: u32::from_be_bytes((&cb[10..14]).try_into().unwrap()) as u64,
},
WRITE_10 => ScsiCommand::Write {
lba: u32::from_be_bytes([cb[2], cb[3], cb[4], cb[5]]) as u64,
len: u16::from_be_bytes([cb[7], cb[8]]) as u64,
},
MODE_SENSE_6 => ScsiCommand::ModeSense6 {
dbd: (cb[1] & 0b00001000) != 0,
page_control: PageControl::try_from_primitive(cb[2] >> 6).unwrap(),
page_code: cb[2] & 0b00111111,
subpage_code: cb[3],
alloc_len: cb[4],
},
MODE_SENSE_10 => ScsiCommand::ModeSense10 {
dbd: (cb[1] & 0b00001000) != 0,
page_control: PageControl::try_from_primitive(cb[2] >> 6).unwrap(),
page_code: cb[2] & 0b00111111,
subpage_code: cb[3],
alloc_len: u16::from_be_bytes([cb[7], cb[8]]),
},
READ_FORMAT_CAPACITIES => ScsiCommand::ReadFormatCapacities {
alloc_len: u16::from_be_bytes([cb[7], cb[8]]),
},
PREVENT_ALLOW_MEDIUM_REMOVAL => ScsiCommand::PreventAllowMediumRemoval {
prevent: (cb[1] & 0b00000001) != 0,
},
START_STOP_UNIT => ScsiCommand::StartStopUnit {
start: (cb[4] & 0b00000001) != 0,
load_eject: (cb[4] & 0b00000010) != 0,
},
_ => ScsiCommand::Unknown,
}
}

162
kernel/src/storage.rs
View File

@@ -1,162 +0,0 @@
use alloc::{string::String, vec::Vec};
use core::str::FromStr;
use embassy_rp::gpio::{Input, Output};
use embassy_rp::peripherals::SPI0;
use embassy_rp::spi::{Blocking, Spi};
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::lazy_lock::LazyLock;
use embassy_sync::mutex::Mutex;
use embassy_time::Delay;
use embedded_hal_bus::spi::ExclusiveDevice;
use embedded_sdmmc::{
Block, BlockCount, BlockDevice, BlockIdx, Directory, SdCard as SdmmcSdCard, TimeSource,
Timestamp, Volume, VolumeIdx, VolumeManager, sdcard::Error,
};
use embedded_sdmmc::{File as SdFile, LfnBuffer, Mode, ShortFileName};
pub const MAX_DIRS: usize = 4;
pub const MAX_FILES: usize = 5;
pub const MAX_VOLUMES: usize = 1;
type Device = ExclusiveDevice<Spi<'static, SPI0, Blocking>, Output<'static>, embassy_time::Delay>;
type SD = SdmmcSdCard<Device, Delay>;
type VolMgr = VolumeManager<SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
type Vol<'a> = Volume<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
type Dir<'a> = Directory<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
pub type File<'a> = SdFile<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>;
pub static SDCARD: LazyLock<Mutex<CriticalSectionRawMutex, Option<SdCard>>> =
LazyLock::new(|| Mutex::new(None));
pub struct DummyTimeSource {}
impl TimeSource for DummyTimeSource {
fn get_timestamp(&self) -> Timestamp {
Timestamp::from_calendar(2022, 1, 1, 0, 0, 0).unwrap()
}
}
#[derive(Clone, PartialEq)]
pub struct FileName {
pub long_name: String,
pub short_name: ShortFileName,
}
pub struct SdCard {
det: Input<'static>,
volume_mgr: VolMgr,
}
impl SdCard {
pub const BLOCK_SIZE: u16 = 512;
pub fn new(sdcard: SD, det: Input<'static>) -> Self {
let volume_mgr = VolumeManager::<_, _, MAX_DIRS, MAX_FILES, MAX_VOLUMES>::new_with_limits(
sdcard,
DummyTimeSource {},
5000,
);
Self {
det: det,
volume_mgr,
}
}
/// Returns true if an SD card is inserted.
/// The DET pin is active-low via mechanical switch in the socket.
pub fn is_attached(&self) -> bool {
self.det.is_low()
}
pub fn size(&self) -> u64 {
let mut result = 0;
self.volume_mgr.device(|sd| {
result = sd.num_bytes().unwrap_or(0);
DummyTimeSource {}
});
result
}
pub fn num_blocks(&self) -> u32 {
let mut result = 0;
self.volume_mgr.device(|sd| {
result = sd.num_blocks().unwrap_or(BlockCount(0)).0;
DummyTimeSource {}
});
result
}
pub fn read_blocks(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), ()> {
let mut res: Result<(), Error> = Ok(());
self.volume_mgr.device(|sd| {
res = sd.read(blocks, start_block_idx);
DummyTimeSource {}
});
res.map_err(|_| ())
}
pub fn write_blocks(&self, blocks: &mut [Block], start_block_idx: BlockIdx) -> Result<(), ()> {
let mut res: Result<(), Error> = Ok(());
self.volume_mgr.device(|sd| {
let res = sd.write(blocks, start_block_idx);
DummyTimeSource {}
});
res.map_err(|_| ())
}
pub fn access_root_dir(&mut self, mut access: impl FnMut(Dir)) {
let volume0 = self.volume_mgr.open_volume(VolumeIdx(0)).unwrap();
let root_dir = volume0.open_root_dir().unwrap();
access(root_dir);
}
pub async fn read_file(
&mut self,
name: &ShortFileName,
mut access: impl FnMut(File),
) -> Result<(), ()> {
let mut res = Err(());
self.access_root_dir(|root_dir| {
if let Ok(file) = root_dir.open_file_in_dir(name, Mode::ReadOnly) {
res = Ok(());
access(file);
}
});
res
}
/// Returns a Vec of file names (long format) that match the given extension (e.g., "BIN")
pub fn list_files_by_extension(&mut self, ext: &str) -> Result<Vec<FileName>, ()> {
let mut result = Vec::new();
// Only proceed if card is inserted
if !self.is_attached() {
return Ok(result);
}
let mut lfn_storage = [0; 50];
let mut lfn_buffer = LfnBuffer::new(&mut lfn_storage);
self.access_root_dir(|dir| {
dir.iterate_dir_lfn(&mut lfn_buffer, |entry, name| {
if let Some(name) = name {
let name = String::from_str(name).unwrap();
if name.contains(ext) {
result.push(FileName {
long_name: name,
short_name: entry.name.clone(),
});
}
}
})
.unwrap()
});
Ok(result)
}
}

152
kernel/src/ui.rs
View File

@@ -1,152 +0,0 @@
use crate::{
BINARY_CH, TASK_STATE, TaskState,
display::{FRAMEBUFFER, SCREEN_HEIGHT, SCREEN_WIDTH},
elf::load_binary,
format,
peripherals::keyboard,
storage::FileName,
};
use alloc::{string::String, vec::Vec};
use core::{fmt::Debug, str::FromStr, sync::atomic::Ordering};
use embassy_sync::{
blocking_mutex::raw::{CriticalSectionRawMutex, ThreadModeRawMutex},
mutex::Mutex,
};
use embedded_graphics::{
Drawable,
mono_font::{MonoTextStyle, ascii::FONT_9X15},
pixelcolor::Rgb565,
prelude::{Dimensions, Point, RgbColor, Size},
primitives::Rectangle,
text::Text,
};
use embedded_layout::{
align::{horizontal, vertical},
layout::linear::LinearLayout,
object_chain::Chain,
prelude::*,
};
use embedded_text::TextBox;
use shared::keyboard::{KeyCode, KeyState};
pub static SELECTIONS: Mutex<CriticalSectionRawMutex, SelectionList> =
Mutex::new(SelectionList::new());
pub async fn ui_handler() {
loop {
if let TaskState::Ui = *TASK_STATE.lock().await {
if let Some(event) = keyboard::read_keyboard_fifo().await {
if let KeyState::Pressed = event.state {
match event.key {
KeyCode::JoyUp => {
let mut selections = SELECTIONS.lock().await;
selections.up();
}
KeyCode::JoyDown => {
let mut selections = SELECTIONS.lock().await;
selections.down();
}
KeyCode::Enter | KeyCode::JoyRight => {
let selections = SELECTIONS.lock().await;
let selection = selections.selections
[selections.current_selection as usize - 1]
.clone();
let entry =
unsafe { load_binary(&selection.short_name).await.unwrap() };
BINARY_CH.send(entry).await;
}
_ => (),
}
}
}
draw_selection().await;
} else {
embassy_time::Timer::after_millis(50).await;
}
}
}
async fn draw_selection() {
let file_names: Vec<FileName> = {
let guard = SELECTIONS.lock().await;
guard.selections.clone()
};
let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
let display_area = unsafe { FRAMEBUFFER.bounding_box() };
const NO_BINS: &str = "No Programs found on SD Card. Ensure programs end with '.bin', and are located in the root directory";
let no_bins = String::from_str(NO_BINS).unwrap();
if file_names.is_empty() {
TextBox::new(
&no_bins,
Rectangle::new(
Point::new(25, 25),
Size::new(display_area.size.width - 50, display_area.size.width - 50),
),
text_style,
)
.draw(unsafe { &mut FRAMEBUFFER })
.unwrap();
} else {
let mut file_names = file_names.iter();
let Some(first) = file_names.next() else {
Text::new(NO_BINS, Point::zero(), text_style)
.draw(unsafe { &mut FRAMEBUFFER })
.unwrap();
return;
};
let chain = Chain::new(Text::new(&first.long_name, Point::zero(), text_style));
// for _ in 0..file_names.len() {
// let chain = chain.append(Text::new(
// file_names.next().unwrap(),
// Point::zero(),
// text_style,
// ));
// }
LinearLayout::vertical(chain)
.with_alignment(horizontal::Center)
.arrange()
.align_to(&display_area, horizontal::Center, vertical::Center)
.draw(unsafe { &mut FRAMEBUFFER })
.unwrap();
}
}
#[derive(Clone)]
pub struct SelectionList {
current_selection: u16,
pub selections: Vec<FileName>,
}
impl SelectionList {
pub const fn new() -> Self {
Self {
selections: Vec::new(),
current_selection: 0,
}
}
pub fn reset(&mut self) {
self.current_selection = 1
}
fn down(&mut self) {
if self.current_selection + 1 < self.selections.len() as u16 {
self.current_selection += 1
}
}
fn up(&mut self) {
if self.current_selection > self.selections.len() as u16 {
self.current_selection -= 1
}
}
}

43
kernel/src/usb.rs
View File

@@ -1,43 +0,0 @@
use crate::{TASK_STATE, TASK_STATE_CHANGED, TaskState, scsi::MassStorageClass};
use embassy_futures::{
join::join,
select::{select, select3},
};
use embassy_rp::{peripherals::USB, usb::Driver};
use embassy_usb::{Builder, Config};
pub async fn usb_handler(driver: Driver<'static, USB>) {
let mut config = Config::new(0xc0de, 0xbabe);
config.manufacturer = Some("LegitCamper");
config.product = Some("PicoCalc");
config.serial_number = Some("01001100");
config.max_power = 100;
config.max_packet_size_0 = 64;
let mut config_descriptor = [0; 256];
let mut bos_descriptor = [0; 64];
let mut control_buf = [0; 64];
let mut builder = Builder::new(
driver,
config,
&mut config_descriptor,
&mut bos_descriptor,
&mut [],
&mut control_buf,
);
let mut scsi = MassStorageClass::new(&mut builder);
let mut usb = builder.build();
loop {
defmt::info!("in: {}", *TASK_STATE.lock().await as u32);
if *TASK_STATE.lock().await == TaskState::Ui {
defmt::info!("running scsi and usb");
select(join(usb.run(), scsi.poll()), TASK_STATE_CHANGED.wait()).await;
} else {
defmt::info!("not in ui state");
TASK_STATE_CHANGED.wait().await;
}
}
}

11
kernel/src/utils.rs
View File

@@ -1,11 +0,0 @@
#[macro_export]
macro_rules! format {
($len:literal, $($arg:tt)*) => {{
use heapless::String;
use core::fmt::Write;
let mut s: String<$len> = String::new();
let _ = write!(&mut s, $($arg)*);
s
}}
}

39
kernel/Cargo.toml → pico/Cargo.toml
View File

@@ -1,15 +1,8 @@
[package]
name = "kernel"
name = "picocalc-os-rs"
version = "0.1.0"
edition = "2024"
[[bin]]
name = "kernel"
path = "src/main.rs"
test = false
doctest = false
bench = false
[features]
default = ["rp235x", "defmt"]
rp2040 = ["embassy-rp/rp2040"]
@@ -30,22 +23,25 @@ defmt = [
# "cyw43-pio/defmt",
]
[dev-dependencies]
embedded-graphics-simulator = { version = "0.7.0", default-features = false }
[dependencies]
embassy-executor = { version = "0.9", features = [
embassy-executor = { version = "0.7", features = [
"arch-cortex-m",
"executor-interrupt",
"executor-thread",
"nightly",
] }
embassy-rp = { version = "0.8.0", features = [
embassy-rp = { version = "0.4.0", features = [
"critical-section-impl",
"unstable-pac",
"time-driver",
"binary-info",
] }
embassy-usb = "0.5.1"
embassy-futures = "0.1.2"
embassy-time = { version = "0.5.0", features = ["generic-queue-8"] }
embassy-embedded-hal = "0.3.1"
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",
@@ -60,30 +56,21 @@ cyw43-pio = { version = "0.3.0", optional = true }
embedded-hal-bus = { version = "0.3.0", features = ["async"] }
embedded-hal = "0.2.7"
embedded-hal_2 = { package = "embedded-hal", version = "1.0.0" }
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"] }
assign-resources = "0.5.0"
defmt = { version = "0.3", optional = true }
defmt-rtt = "0.4.2"
embedded-sdmmc = { version = "0.9", default-features = false }
st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", rev = "1d15123929fa7ef73d5d6aead7faf1bba50ce915" } # async branch
embedded-graphics = { version = "0.8.1" }
embedded-text = "0.7.2"
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" }
shared = { path = "../shared" }
static_cell = "2.1.1"
bitflags = "2.9.1"
heapless = "0.8.0"
num_enum = { version = "0.7.4", default-features = false }
goblin = { version = "0.10.0", default-features = false, features = ["elf32"] }
talc = "4.4.3"
spin = "0.10.0"
shared = { path = "../shared" }
abi_sys = { path = "../abi_sys" }

0
kernel/build.rs → pico/build.rs
View File

28
kernel/memory.x → pico/memory.x
View File

@@ -1,10 +1,22 @@
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
/* Reserve a block of RAM for the user app */
USERAPP : ORIGIN = 0x20010000, LENGTH = 192K
/*
* 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
}
@@ -61,11 +73,3 @@ SECTIONS {
PROVIDE(start_to_end = __end_block_addr - __start_block_addr);
PROVIDE(end_to_start = __start_block_addr - __end_block_addr);
SECTIONS {
.userapp (NOLOAD) :
{
__userapp_start__ = ORIGIN(USERAPP);
__userapp_end__ = ORIGIN(USERAPP) + LENGTH(USERAPP);
} > USERAPP
}

61
pico/src/display.rs Normal file
View File

@@ -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;
}
}

60
pico/src/main.rs Normal file
View File

@@ -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();
}

207
pico/src/peripherals/keyboard.rs Normal file
View File

@@ -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),
},
}
}
}

24
kernel/src/peripherals/mod.rs → pico/src/peripherals/mod.rs
View File

@@ -6,36 +6,42 @@ use embassy_rp::{
peripherals::I2C1,
};
use embassy_sync::{
blocking_mutex::raw::CriticalSectionRawMutex, lazy_lock::LazyLock, mutex::Mutex,
blocking_mutex::raw::NoopRawMutex, channel::Sender, lazy_lock::LazyLock, mutex::Mutex,
};
use embassy_time::Timer;
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<CriticalSectionRawMutex, Option<I2CBUS>>> =
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) {
#[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;
// empty keys
while read_keyboard_fifo().await.is_some() {}
// set_lcd_backlight(255).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

2
rust-toolchain.toml
View File

@@ -1,4 +1,4 @@
[toolchain]
channel = "nightly-2025-06-18"
components = ["rust-src", "rustfmt", "rust-analyzer"]
targets = ["thumbv6m-none-eabi"]
targets = ["thumbv6m-none-eabi", "x86_64-unknown-linux-gnu"]

9
shared/Cargo.toml
View File

@@ -3,9 +3,8 @@ name = "shared"
version = "0.1.0"
edition = "2024"
[features]
defmt = ["dep:defmt"]
[dependencies]
bitflags = "2.9.1"
defmt = { version = "1.0.1", optional = true }
arrform = "0.1.1"
embedded-graphics = "0.8.1"
embedded-graphics-core = "0.4.0"
embedded-layout = "0.4.2"

203
shared/src/lib.rs
View File

@@ -1,142 +1,77 @@
#![no_std]
pub mod screen {
use arrform::{ArrForm, arrform};
use embedded_graphics::{
Drawable,
draw_target::DrawTarget,
mono_font::{
MonoTextStyle,
ascii::{FONT_6X10, FONT_9X15, FONT_10X20},
},
pixelcolor::Rgb565,
prelude::{Point, RgbColor, Size},
primitives::Rectangle,
text::Text,
};
use embedded_layout::{
align::{horizontal, vertical},
layout::linear::LinearLayout,
prelude::*,
};
pub mod keyboard {
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;
}
pub const SCREEN_WIDTH: usize = 320;
pub const SCREEN_HEIGHT: usize = 320;
pub const STATUS_BAR_WIDTH: usize = 320;
pub const STATUS_BAR_HEIGHT: usize = 40;
pub struct UI {
pub status_bar: StatusBar,
}
#[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(C)]
#[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),
impl UI {
pub fn new() -> Self {
Self {
status_bar: StatusBar {
battery: 100,
backlight: 100,
volume: 100,
},
}
}
pub 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,
}
}

4
abi_sys/Cargo.toml → simulator/Cargo.toml
View File

@@ -1,8 +1,10 @@
[package]
name = "abi_sys"
name = "simulator"
version = "0.1.0"
edition = "2024"
[dependencies]
embedded-graphics = "0.8.1"
embedded-graphics-simulator = "0.7.0"
embedded-layout = "0.4.2"
shared = { path = "../shared" }

20
simulator/src/main.rs Normal file
View File

@@ -0,0 +1,20 @@
use embedded_graphics::{pixelcolor::Rgb565, prelude::Size};
use embedded_graphics_simulator::{
BinaryColorTheme, OutputSettingsBuilder, SimulatorDisplay, Window,
};
use shared::screen::{SCREEN_HEIGHT, SCREEN_WIDTH, UI};
fn main() -> Result<(), core::convert::Infallible> {
let mut display =
SimulatorDisplay::<Rgb565>::new(Size::new(SCREEN_WIDTH as u32, SCREEN_HEIGHT as u32));
let mut ui = UI::new();
ui.draw_status_bar(&mut display);
let output_settings = OutputSettingsBuilder::new().build();
Window::new("Hello World", &output_settings).show_static(&display);
Ok(())
}

8
user-apps/calculator/Cargo.toml
View File

@@ -1,8 +0,0 @@
[package]
name = "calculator"
version = "0.1.0"
edition = "2024"
[dependencies]
abi = { path = "../../abi" }
embedded-graphics = "0.8.1"

28
user-apps/calculator/build.rs
View File

@@ -1,28 +0,0 @@
//! 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());
println!("cargo:rerun-if-changed=memory.x");
println!("cargo:rustc-link-arg-bins=-Tmemory.x");
}

77
user-apps/calculator/src/main.rs
View File

@@ -1,77 +0,0 @@
#![no_std]
#![no_main]
extern crate alloc;
use abi::{KeyCode, display::Display, embassy_time, get_key, print, sleep};
use alloc::{boxed::Box, string::String, vec};
use core::{panic::PanicInfo, pin::Pin};
use embedded_graphics::{
Drawable,
geometry::{Dimensions, Point},
mono_font::{MonoTextStyle, ascii::FONT_6X10},
pixelcolor::Rgb565,
prelude::{Primitive, RgbColor, Size},
primitives::{PrimitiveStyle, Rectangle},
text::{Alignment, Text},
};
#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
loop {}
}
pub async fn main() {
print("Starting Async Calculator app");
let mut display = Display;
let character_style = MonoTextStyle::new(&FONT_6X10, Rgb565::RED);
let mut text = vec!['T', 'y', 'p', 'e'];
let mut dirty = true;
let mut last_bounds: Option<Rectangle> = None;
loop {
if dirty {
if let Some(bounds) = last_bounds {
Rectangle::new(bounds.top_left, bounds.size)
.into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK))
.draw(&mut display)
.unwrap();
}
let text = text.iter().cloned().collect::<String>();
let aligned_text = Text::with_alignment(
&text,
display.bounding_box().center(),
character_style,
Alignment::Center,
);
last_bounds = Some(aligned_text.bounding_box());
aligned_text.draw(&mut display).unwrap();
dirty = false;
}
if let Some(event) = get_key() {
dirty = true;
match event.key {
KeyCode::Char(ch) => {
text.push(ch);
}
KeyCode::Del => {
text.clear();
}
KeyCode::Backspace => {
text.pop();
}
KeyCode::Esc => return,
_ => (),
}
}
}
}
#[unsafe(no_mangle)]
pub extern "Rust" fn _start() -> Pin<Box<dyn Future<Output = ()>>> {
Box::pin(async { main().await })
}

33
user-apps/memory.x
View File

@@ -1,33 +0,0 @@
MEMORY
{
/* Must match the USERAPP region in the kernel linker script */
RAM : ORIGIN = 0x20010000, LENGTH = 192K
}
SECTIONS
{
/* Reserve first 1KB for patchable symbols */
.user_reloc (NOLOAD) : ALIGN(4)
{
__user_reloc_start = .;
KEEP(*(.user_reloc*));
__user_reloc_end = .;
} > RAM
.text : ALIGN(4)
{
*(.text .text.*);
*(.rodata .rodata.*);
} > RAM
.data : ALIGN(4)
{
*(.data .data.*);
} > RAM
.bss : ALIGN(4)
{
*(.bss .bss.*);
*(COMMON);
} > RAM
}