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

WIP

Browse Source
This commit is contained in:
sawyer bristol
2025-09-13 13:57:41 -06:00
parent 70ecbcafc3
commit 1994d74a17
12 changed files with 154 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/Cargo.toml
View File

@@ -70,7 +70,7 @@ 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 = "87abf450404865dcb535292e9e1a6a2457fd4599" } # async branch
st7365p-lcd = { git = "https://github.com/legitcamper/st7365p-lcd-rs", rev = "2a484aaab5f6b9824cc813fe4ae087250c9e39c1" } # async branch
embedded-graphics = { version = "0.8.1" }
embedded-text = "0.7.2"
embedded-layout = "0.4.2"

31
kernel/src/abi.rs
View File

@@ -1,9 +1,10 @@
use core::pin::Pin;
use core::{pin::Pin, time::Duration};
use abi_sys::{DrawIterAbi, GetKeyAbi, Pixel, PrintAbi};
use abi_sys::{DrawIterAbi, GetKeyAbi, Pixel, PrintAbi, SleepAbi};
use alloc::boxed::Box;
use defmt::info;
use embassy_futures::block_on;
use embassy_time::Timer;
use embedded_graphics::{
Drawable,
draw_target::DrawTarget,
@@ -17,6 +18,7 @@ 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;
@@ -24,20 +26,23 @@ pub extern "Rust" fn print(msg: &str) {
defmt::info!("{:?}", msg);
}
pub extern "Rust" fn sleep(ticks: u64) {
for _ in 0..ticks {
for _ in 0..100 {
cortex_m::asm::nop();
}
}
}
// TODO: maybe return result
pub extern "Rust" fn draw_iter(pixels: &[Pixel<Rgb565>]) {
for _ in 0..10 {
if let Some(mut framebuffer) = FRAMEBUFFER.try_lock().ok() {
for _ in 0..10 {
// kernel takes() framebuffer
if let Some(framebuffer) = framebuffer.as_mut() {
framebuffer.draw_iter(pixels.iter().copied()).unwrap();
}
break;
}
break;
loop {
let fb = FRAMEBUFFER.get().try_lock();
if let Ok(mut fb) = fb {
fb.draw_iter(pixels.iter().copied()).unwrap();
return;
}
cortex_m::asm::nop();
sleep(1)
}
}

37
kernel/src/display.rs
View File

@@ -3,11 +3,16 @@ use embassy_rp::{
peripherals::{PIN_13, PIN_14, PIN_15, SPI1},
spi::{Async, Spi},
};
use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex};
use embassy_sync::{
blocking_mutex::raw::CriticalSectionRawMutex, lazy_lock::LazyLock, mutex::Mutex,
};
use embassy_time::{Delay, Timer};
use embedded_graphics::{
draw_target::DrawTarget,
pixelcolor::{Rgb565, RgbColor},
};
use embedded_hal_bus::spi::ExclusiveDevice;
use st7365p_lcd::{FrameBuffer, ST7365P};
use static_cell::StaticCell;
type DISPLAY = ST7365P<
ExclusiveDevice<Spi<'static, SPI1, Async>, Output<'static>, Delay>,
@@ -20,8 +25,8 @@ pub const SCREEN_WIDTH: usize = 320;
pub const SCREEN_HEIGHT: usize = 320;
type FB = FrameBuffer<SCREEN_WIDTH, SCREEN_HEIGHT, { SCREEN_WIDTH * SCREEN_HEIGHT }>;
static FRAMEBUFFER_CELL: StaticCell<FB> = StaticCell::new();
pub static FRAMEBUFFER: Mutex<CriticalSectionRawMutex, Option<&'static mut FB>> = Mutex::new(None);
pub static FRAMEBUFFER: LazyLock<Mutex<CriticalSectionRawMutex, FB>> =
LazyLock::new(|| Mutex::new(FrameBuffer::new()));
pub async fn init_display(
spi: Spi<'static, SPI1, Async>,
@@ -38,27 +43,27 @@ pub async fn init_display(
true,
Delay,
);
let framebuffer = FRAMEBUFFER_CELL.init(FrameBuffer::new());
let mut fb = FRAMEBUFFER.get().lock().await;
display.init().await.unwrap();
display.set_custom_orientation(0x40).await.unwrap();
framebuffer.draw(&mut display).await.unwrap();
display.draw(&mut fb).await.unwrap();
display.set_on().await.unwrap();
FRAMEBUFFER.lock().await.replace(framebuffer);
display
}
pub async fn clear_fb() {
let mut fb = FRAMEBUFFER.get().lock().await;
let fb = &mut *fb;
fb.clear(Rgb565::BLACK).unwrap();
}
pub async fn display_handler(mut display: DISPLAY) {
loop {
let fb: &mut FB = {
let mut guard = FRAMEBUFFER.lock().await;
guard.take().unwrap() // take ownership
}; // guard dropped
fb.partial_draw_batched(&mut display).await.unwrap();
// Put it back
FRAMEBUFFER.lock().await.replace(fb);
{
let mut fb = FRAMEBUFFER.get().lock().await;
display.partial_draw_batched(&mut fb).await.unwrap();
}
Timer::after_millis(32).await; // 30 fps
}

1
kernel/src/elf.rs
View File

@@ -53,6 +53,7 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Result<EntryFn, &str> {
// 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),
];

17
kernel/src/main.rs
View File

@@ -20,7 +20,7 @@ mod utils;
use core::sync::atomic::Ordering;
use crate::{
display::{display_handler, init_display},
display::{FRAMEBUFFER, clear_fb, display_handler, init_display},
elf::load_binary,
peripherals::{
conf_peripherals,
@@ -49,7 +49,9 @@ use embassy_rp::{
spi::{self, Spi},
usb as embassy_rp_usb,
};
use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, channel::Channel, mutex::Mutex};
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;
@@ -75,7 +77,9 @@ static ALLOCATOR: Talck<spin::Mutex<()>, ClaimOnOom> =
.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,
@@ -131,6 +135,7 @@ async fn userland_task() {
let recv = BINARY_CH.receiver();
loop {
let entry = recv.receive().await;
defmt::info!("Got Entry");
// disable kernel ui
{
@@ -138,6 +143,8 @@ async fn userland_task() {
*state = TaskState::Kernel;
}
// clear_fb().await; // blocks future exec?
defmt::info!("Executing Binary");
entry().await;
@@ -237,8 +244,8 @@ async fn kernel_task(display: Display, sd: Sd, mcu: Mcu, usb: USB) {
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 usb = embassy_rp_usb::Driver::new(usb, Irqs);
let usb_fut = usb_handler(usb);
let key_abi_fut = async {
loop {
@@ -247,7 +254,7 @@ async fn kernel_task(display: Display, sd: Sd, mcu: Mcu, usb: USB) {
}
};
join4(display_fut, ui_fut, binary_search_fut, key_abi_fut).await;
join5(display_fut, ui_fut, usb_fut, binary_search_fut, key_abi_fut).await;
}
static mut KEY_CACHE: Queue<KeyEvent, 32> = Queue::new();

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

@@ -8,18 +8,17 @@ use heapless::Vec;
mod scsi_types;
use scsi_types::*;
use crate::storage::SdCard;
use crate::storage::{SDCARD, SdCard};
const BULK_ENDPOINT_PACKET_SIZE: usize = 64;
pub struct MassStorageClass<'d, 's, D: Driver<'d>> {
sdcard: &'s SdCard,
pub struct MassStorageClass<'d, D: Driver<'d>> {
bulk_out: D::EndpointOut,
bulk_in: D::EndpointIn,
}
impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
pub fn new(builder: &mut Builder<'d, D>, sdcard: &'s SdCard) -> Self {
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);
@@ -27,11 +26,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
let bulk_out = alt.endpoint_bulk_out(BULK_ENDPOINT_PACKET_SIZE as u16);
let bulk_in = alt.endpoint_bulk_in(BULK_ENDPOINT_PACKET_SIZE as u16);
Self {
bulk_out,
bulk_in,
sdcard,
}
Self { bulk_out, bulk_in }
}
pub async fn poll(&mut self) {
@@ -139,7 +134,9 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
self.bulk_in.write(&response[..len]).await.map_err(|_| ())
}
ScsiCommand::TestUnitReady => {
if self.sdcard.is_attached() {
let guard = SDCARD.get().lock().await;
let sdcard = guard.as_ref().unwrap();
if sdcard.is_attached() {
Ok(())
} else {
Err(())
@@ -185,8 +182,11 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
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 = self.sdcard.size() / block_size;
let total_blocks = sdcard.size() / block_size;
let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
@@ -196,8 +196,11 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
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 = self.sdcard.size() / block_size;
let total_blocks = sdcard.size() / block_size;
let last_lba = total_blocks.checked_sub(1).unwrap_or(0);
@@ -209,9 +212,12 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
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);
self.sdcard.read_blocks(&mut block, block_idx)?;
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(|_| ())?;
}
@@ -219,6 +225,9 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
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]
@@ -227,13 +236,16 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, 's, D> {
{
self.bulk_out.read(chunk).await.map_err(|_| ())?;
}
self.sdcard.write_blocks(&mut block, block_idx)?;
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 = (self.sdcard.size() / block_size as u64) as u32;
let num_blocks = (sdcard.size() / block_size as u64) as u32;
let mut response = [0u8; 12];

104
kernel/src/ui.rs
View File

@@ -5,36 +5,21 @@ use crate::{
format,
peripherals::keyboard,
storage::FileName,
usb::RESTART_USB,
};
use alloc::{string::String, vec::Vec};
use core::{fmt::Debug, str::FromStr, 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::{CriticalSectionRawMutex, ThreadModeRawMutex},
mutex::Mutex,
signal::Signal,
};
use embassy_time::{Delay, Timer};
use embedded_graphics::{
Drawable,
draw_target::DrawTarget,
mono_font::{
MonoTextStyle,
ascii::{FONT_6X9, FONT_6X10, FONT_9X15, FONT_10X20},
},
mono_font::{MonoTextStyle, ascii::FONT_9X15},
pixelcolor::Rgb565,
prelude::{Dimensions, Point, Primitive, RgbColor, Size},
primitives::{PrimitiveStyle, Rectangle, StyledDrawable},
prelude::{Dimensions, Point, RgbColor, Size},
primitives::Rectangle,
text::Text,
};
use embedded_hal_async::spi::SpiDevice;
use embedded_hal_bus::spi::{ExclusiveDevice, NoDelay};
use embedded_layout::{
align::{horizontal, vertical},
layout::linear::LinearLayout,
@@ -77,6 +62,8 @@ pub async fn ui_handler() {
}
draw_selection().await;
} else {
embassy_time::Timer::after_millis(50).await;
}
}
}
@@ -87,51 +74,50 @@ async fn draw_selection() {
guard.selections.clone()
};
let mut fb_lock = FRAMEBUFFER.lock().await;
if let Some(fb) = fb_lock.as_mut() {
let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
let display_area = fb.bounding_box();
let mut fb = FRAMEBUFFER.get().lock().await;
let text_style = MonoTextStyle::new(&FONT_9X15, Rgb565::WHITE);
let display_area = fb.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();
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(*fb)
.unwrap();
} else {
let mut file_names = file_names.iter();
let Some(first) = file_names.next() else {
Text::new("No Programs found on SD Card\nEnsure programs end with '.bin',\nand are located in the root directory",
Point::zero(), text_style).draw(*fb).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(*fb)
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(&mut *fb)
.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(&mut *fb)
.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(&mut *fb)
.unwrap();
}
}

34
kernel/src/usb.rs
View File

@@ -1,6 +1,5 @@
use core::sync::atomic::Ordering;
use crate::{
TASK_STATE, TASK_STATE_CHANGED, TaskState,
scsi::MassStorageClass,
storage::{SDCARD, SdCard},
};
@@ -13,9 +12,6 @@ use embassy_sync::{blocking_mutex::raw::ThreadModeRawMutex, signal::Signal};
use embassy_usb::{Builder, Config};
use portable_atomic::AtomicBool;
pub static RESTART_USB: Signal<ThreadModeRawMutex, ()> = Signal::new();
pub static ENABLE_SCSI: AtomicBool = AtomicBool::new(false);
pub async fn usb_handler(driver: Driver<'static, USB>) {
let mut config = Config::new(0xc0de, 0xbabe);
config.manufacturer = Some("LegitCamper");
@@ -37,27 +33,17 @@ pub async fn usb_handler(driver: Driver<'static, USB>) {
&mut control_buf,
);
let lock = SDCARD.get().lock().await;
let sdcard = lock.as_ref().unwrap();
let mut scsi = MassStorageClass::new(&mut builder, &sdcard);
let mut scsi = MassStorageClass::new(&mut builder);
let mut usb = builder.build();
loop {
select3(
async {
loop {
RESTART_USB.wait().await;
return;
}
},
usb.run(),
async {
if ENABLE_SCSI.load(Ordering::Acquire) {
scsi.poll().await
}
},
)
.await;
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;
}
}
}