From d8a5ab465ef1fb92bee1cf83004fdffba58c18fc Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 30 Sep 2025 20:27:07 -0600 Subject: [PATCH 01/19] WIP --- Cargo.lock | 19 +++++++ Cargo.toml | 1 + abi/src/lib.rs | 5 +- abi_sys/src/lib.rs | 26 +++++++++ justfile | 1 + kernel/Cargo.toml | 1 + kernel/src/abi.rs | 29 ++++++++-- kernel/src/audio.rs | 52 ++++++++++++++++++ kernel/src/elf.rs | 2 + kernel/src/main.rs | 26 ++++++++- user-apps/wav_player/Cargo.toml | 10 ++++ user-apps/wav_player/build.rs | 28 ++++++++++ user-apps/wav_player/src/main.rs | 92 ++++++++++++++++++++++++++++++++ 13 files changed, 285 insertions(+), 7 deletions(-) create mode 100644 kernel/src/audio.rs create mode 100644 user-apps/wav_player/Cargo.toml create mode 100644 user-apps/wav_player/build.rs create mode 100644 user-apps/wav_player/src/main.rs diff --git a/Cargo.lock b/Cargo.lock index d5cafc5..8b76c5a 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -828,6 +828,14 @@ dependencies = [ "embedded-io-async", ] +[[package]] +name = "embedded-audio" +version = "0.1.0" +source = "git+https://github.com/LegitCamper/embedded-audio#087784644d810b94dd659a03dbed4795dfb0bd24" +dependencies = [ + "heapless", +] + [[package]] name = "embedded-graphics" version = "0.8.1" @@ -1343,6 +1351,7 @@ dependencies = [ "goblin", "heapless", "kolibri-embedded-gui", + "micromath", "num_enum 0.7.4", "once_cell", "panic-probe", @@ -2516,6 +2525,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "wav_player" +version = "0.1.0" +dependencies = [ + "abi", + "embedded-audio", + "embedded-graphics", + "rand", +] + [[package]] name = "winapi" version = "0.3.9" diff --git a/Cargo.toml b/Cargo.toml index 3080f3d..3e2e0ae 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -7,6 +7,7 @@ members = [ "user-apps/calculator", "user-apps/snake", "user-apps/gallery", + "user-apps/wav_player", ] [profile.release] diff --git a/abi/src/lib.rs b/abi/src/lib.rs index e24f88c..2f4b96a 100644 --- a/abi/src/lib.rs +++ b/abi/src/lib.rs @@ -1,7 +1,10 @@ #![no_std] +pub use abi_sys::{ + AUDIO_BUFFER_LEN, audio_buffer_ready, file_len, get_key, list_dir, lock_display, print, + read_file, send_audio_buffer, sleep, +}; use abi_sys::{RngRequest, draw_iter, gen_rand}; -pub use abi_sys::{file_len, get_key, list_dir, lock_display, print, read_file, sleep}; use rand_core::RngCore; pub use shared::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers}; use talc::*; diff --git a/abi_sys/src/lib.rs b/abi_sys/src/lib.rs index 2384c0a..f40a74f 100644 --- a/abi_sys/src/lib.rs +++ b/abi_sys/src/lib.rs @@ -31,6 +31,8 @@ pub enum CallAbiTable { ListDir = 6, ReadFile = 7, FileLen = 8, + AudioBufferReady = 9, + SendAudioBuffer = 10, } pub type PrintAbi = extern "C" fn(ptr: *const u8, len: usize); @@ -145,3 +147,27 @@ pub fn file_len(file: &str) -> usize { f(file.as_ptr(), file.len()) } } + +pub type AudioBufferReady = extern "C" fn() -> bool; + +#[allow(unused)] +pub fn audio_buffer_ready() -> bool { + unsafe { + let ptr = CALL_ABI_TABLE[CallAbiTable::AudioBufferReady as usize]; + let f: AudioBufferReady = core::mem::transmute(ptr); + f() + } +} + +pub const AUDIO_BUFFER_LEN: usize = 1024; + +pub type SendAudioBuffer = extern "C" fn(ptr: *const u8, len: usize); + +#[allow(unused)] +pub fn send_audio_buffer(buf: &[u8; AUDIO_BUFFER_LEN]) { + unsafe { + let ptr = CALL_ABI_TABLE[CallAbiTable::SendAudioBuffer as usize]; + let f: SendAudioBuffer = core::mem::transmute(ptr); + f(buf.as_ptr(), buf.len()) + } +} diff --git a/justfile b/justfile index d087935..6aa314c 100644 --- a/justfile +++ b/justfile @@ -13,3 +13,4 @@ userapps: just userapp calculator just userapp snake just userapp gallery + just userapp wav_player diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 4c582d3..d8ccc74 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -94,3 +94,4 @@ bumpalo = "3.19.0" shared = { path = "../shared" } abi_sys = { path = "../abi_sys" } +micromath = "2.1.0" diff --git a/kernel/src/abi.rs b/kernel/src/abi.rs index 3c31cf2..b88a998 100644 --- a/kernel/src/abi.rs +++ b/kernel/src/abi.rs @@ -1,16 +1,17 @@ use abi_sys::{ - DrawIterAbi, FileLen, GenRand, GetKeyAbi, ListDir, LockDisplay, Modifiers, PrintAbi, ReadFile, - RngRequest, SleepAbi, + AUDIO_BUFFER_LEN, AudioBufferReady, DrawIterAbi, FileLen, GenRand, GetKeyAbi, ListDir, + LockDisplay, Modifiers, PrintAbi, ReadFile, RngRequest, SendAudioBuffer, SleepAbi, }; use alloc::{string::ToString, vec::Vec}; use core::sync::atomic::Ordering; use embassy_rp::clocks::{RoscRng, clk_sys_freq}; use embedded_graphics::{Pixel, draw_target::DrawTarget, pixelcolor::Rgb565}; -use embedded_sdmmc::{DirEntry, LfnBuffer, ShortFileName}; +use embedded_sdmmc::{DirEntry, LfnBuffer}; use heapless::spsc::Queue; use shared::keyboard::KeyEvent; use crate::{ + audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY}, display::{FB_PAUSED, FRAMEBUFFER}, storage::{Dir, File, SDCARD}, }; @@ -181,7 +182,9 @@ pub extern "C" fn read_file( if !file.is_empty() { sd.access_root_dir(|root| { if let Ok(result) = recurse_file(&root, &file[1..], |file| { - file.seek_from_start(start_from as u32).unwrap(); + if file.offset() as usize != start_from { + file.seek_from_start(start_from as u32).unwrap(); + } file.read(&mut buf).unwrap() }) { read = result @@ -210,3 +213,21 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize { } len as usize } + +const _: AudioBufferReady = audio_buffer_ready; +pub extern "C" fn audio_buffer_ready() -> bool { + AUDIO_BUFFER_READY.load(Ordering::Acquire) +} + +const _: SendAudioBuffer = send_audio_buffer; +pub extern "C" fn send_audio_buffer(ptr: *const u8, len: usize) { + // SAFETY: caller guarantees `ptr` is valid for `len` bytes + let buf = unsafe { core::slice::from_raw_parts(ptr, len) }; + + while !AUDIO_BUFFER_READY.load(Ordering::Acquire) {} + + if buf.len() == AUDIO_BUFFER_LEN { + unsafe { AUDIO_BUFFER.copy_from_slice(buf) }; + AUDIO_BUFFER_READY.store(false, Ordering::Release) + } +} diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs new file mode 100644 index 0000000..30c75e0 --- /dev/null +++ b/kernel/src/audio.rs @@ -0,0 +1,52 @@ +use core::{ + sync::atomic::{AtomicBool, Ordering}, + time::Duration, +}; +use embassy_rp::{ + Peri, + pio::Pio, + pio_programs::pwm::{PioPwm, PioPwmProgram}, + pwm::{Config, Pwm, SetDutyCycle}, +}; +use embassy_time::Timer; + +use crate::{Audio, Irqs}; + +const AUDIO_BUFFER_LEN: usize = 1024; +const _: () = assert!(AUDIO_BUFFER_LEN == abi_sys::AUDIO_BUFFER_LEN); +pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_LEN] = [0; AUDIO_BUFFER_LEN]; +static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_LEN] = [0; AUDIO_BUFFER_LEN]; + +pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true); + +pub const SAMPLE_RATE_HZ: u32 = 22_050; + +#[embassy_executor::task] +pub async fn audio_handler(audio: Audio) { + let var_name = Pio::new(audio.pio_left, Irqs); + let Pio { + mut common, sm0, .. + } = var_name; + + let prg = PioPwmProgram::new(&mut common); + let mut pwm_pio = PioPwm::new(&mut common, sm0, audio.left, &prg); + + let period = Duration::from_nanos(1_000_000_000 / SAMPLE_RATE_HZ as u64); + pwm_pio.set_period(period); + + pwm_pio.start(); + + let sample_interval = 1_000_000 / SAMPLE_RATE_HZ as u64; // in µs ≈ 45 µs + + loop { + for &sample in unsafe { &AUDIO_BUFFER }.iter() { + let period_ns = period.as_nanos() as u32; + let duty_ns = period_ns * (sample as u32) / 255; + pwm_pio.write(Duration::from_nanos(duty_ns as u64)); + Timer::after_micros(sample_interval).await; // sample interval = 1 / sample rate + } + + unsafe { core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1) }; + AUDIO_BUFFER_READY.store(true, Ordering::Release) + } +} diff --git a/kernel/src/elf.rs b/kernel/src/elf.rs index 488e11e..397baca 100644 --- a/kernel/src/elf.rs +++ b/kernel/src/elf.rs @@ -204,6 +204,8 @@ fn patch_abi( CallAbiTable::ListDir => abi::list_dir as usize, CallAbiTable::ReadFile => abi::read_file as usize, CallAbiTable::FileLen => abi::file_len as usize, + CallAbiTable::AudioBufferReady => abi::audio_buffer_ready as usize, + CallAbiTable::SendAudioBuffer => abi::send_audio_buffer as usize, }; unsafe { table_base.add(idx as usize).write(ptr); diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 431fc50..48fb3d6 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -7,6 +7,7 @@ extern crate alloc; mod abi; +mod audio; mod display; mod elf; mod framebuffer; @@ -19,6 +20,7 @@ mod utils; use crate::{ abi::KEY_CACHE, + audio::audio_handler, display::{FRAMEBUFFER, display_handler, init_display}, peripherals::{ conf_peripherals, @@ -48,8 +50,10 @@ use embassy_rp::{ 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, + PIN_16, PIN_17, PIN_18, PIN_19, PIN_22, PIN_26, PIN_27, PIO0, PIO1, PWM_SLICE5, SPI0, SPI1, + USB, }, + pio, spi::{self, Spi}, usb as embassy_rp_usb, }; @@ -65,6 +69,7 @@ use talc::*; embassy_rp::bind_interrupts!(struct Irqs { I2C1_IRQ => i2c::InterruptHandler; USBCTRL_IRQ => embassy_rp_usb::InterruptHandler; + PIO0_IRQ_0 => pio::InterruptHandler; }); static mut CORE1_STACK: Stack<16384> = Stack::new(); @@ -105,6 +110,12 @@ async fn main(_spawner: Spawner) { data: p.PIN_14, reset: p.PIN_15, }; + let audio = Audio { + pio_left: p.PIO0, + pio_right: p.PIO1, + left: p.PIN_26, + right: p.PIN_27, + }; let sd = Sd { spi: p.SPI0, clk: p.PIN_18, @@ -119,7 +130,9 @@ async fn main(_spawner: Spawner) { data: p.PIN_6, }; let executor0 = EXECUTOR0.init(Executor::new()); - executor0.run(|spawner| unwrap!(spawner.spawn(kernel_task(spawner, display, sd, mcu, p.USB)))); + executor0.run(|spawner| { + unwrap!(spawner.spawn(kernel_task(spawner, display, audio, sd, mcu, p.USB))) + }); } // One-slot channel to pass EntryFn from core1 @@ -168,6 +181,12 @@ struct Display { data: Peri<'static, PIN_14>, reset: Peri<'static, PIN_15>, } +struct Audio { + pio_left: Peri<'static, PIO0>, + pio_right: Peri<'static, PIO1>, + left: Peri<'static, PIN_26>, + right: Peri<'static, PIN_27>, +} struct Sd { spi: Peri<'static, SPI0>, clk: Peri<'static, PIN_18>, @@ -225,6 +244,7 @@ async fn setup_sd(sd: Sd) { async fn kernel_task( spawner: Spawner, display: Display, + audio: Audio, sd: Sd, mcu: Mcu, usb: Peri<'static, USB>, @@ -234,6 +254,8 @@ async fn kernel_task( setup_display(display, spawner).await; setup_sd(sd).await; + spawner.spawn(audio_handler(audio)).unwrap(); + let _usb = embassy_rp_usb::Driver::new(usb, Irqs); // spawner.spawn(usb_handler(usb)).unwrap(); diff --git a/user-apps/wav_player/Cargo.toml b/user-apps/wav_player/Cargo.toml new file mode 100644 index 0000000..85c67ac --- /dev/null +++ b/user-apps/wav_player/Cargo.toml @@ -0,0 +1,10 @@ +[package] +name = "wav_player" +version = "0.1.0" +edition = "2024" + +[dependencies] +abi = { path = "../../abi" } +embedded-graphics = "0.8.1" +rand = { version = "0.9.0", default-features = false } +embedded-audio = { git = "https://github.com/LegitCamper/embedded-audio" } diff --git a/user-apps/wav_player/build.rs b/user-apps/wav_player/build.rs new file mode 100644 index 0000000..332a55b --- /dev/null +++ b/user-apps/wav_player/build.rs @@ -0,0 +1,28 @@ +//! 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"); +} diff --git a/user-apps/wav_player/src/main.rs b/user-apps/wav_player/src/main.rs new file mode 100644 index 0000000..3a970b5 --- /dev/null +++ b/user-apps/wav_player/src/main.rs @@ -0,0 +1,92 @@ +#![no_std] +#![no_main] + +extern crate alloc; +use abi::{ + AUDIO_BUFFER_LEN, KeyCode, KeyState, Rng, audio_buffer_ready, + display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, + file_len, get_key, lock_display, print, read_file, send_audio_buffer, sleep, +}; +use alloc::{format, string::String}; +use core::panic::PanicInfo; +use embedded_audio::{AudioFile, PlatformFile, PlatformFileError, wav::Wav}; +use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor}; + +#[panic_handler] +fn panic(info: &PanicInfo) -> ! { + print(&format!( + "user panic: {} @ {:?}", + info.message(), + info.location(), + )); + loop {} +} + +#[unsafe(no_mangle)] +pub extern "Rust" fn _start() { + main() +} + +pub fn main() { + print("Starting Wav player app"); + let mut display = Display; + + let mut buf = [0_u8; AUDIO_BUFFER_LEN]; + + let file = File::new(String::from("/music/test.wav")); + let mut wav = Wav::new(file).unwrap(); + loop { + if audio_buffer_ready() { + if wav.is_eof() { + wav.restart().unwrap() + } + + wav.read(&mut buf).unwrap(); + send_audio_buffer(&buf); + } + } +} + +struct File { + current_pos: usize, + file: String, +} + +impl File { + fn new(file: String) -> Self { + Self { + current_pos: 0, + file, + } + } +} + +impl PlatformFile for File { + fn read(&mut self, buf: &mut [u8]) -> Result { + let read = read_file(&self.file, self.current_pos, buf); + Ok(read) + } + + fn seek_from_current(&mut self, offset: i64) -> Result<(), PlatformFileError> { + if offset.is_positive() { + self.current_pos += offset as usize; + } else { + self.current_pos -= offset as usize; + } + Ok(()) + } + + fn seek_from_start(&mut self, offset: usize) -> Result<(), PlatformFileError> { + self.current_pos = offset; + Ok(()) + } + + fn seek_from_end(&mut self, offset: usize) -> Result<(), PlatformFileError> { + self.current_pos = self.length() - offset; + Ok(()) + } + + fn length(&mut self) -> usize { + file_len(&self.file) + } +} From 4c63f77c243164117820ed851efad61718c5c1d6 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Wed, 1 Oct 2025 13:36:25 -0600 Subject: [PATCH 02/19] WIP --- kernel/src/audio.rs | 143 ++++++++++++++++++++++++------- kernel/src/main.rs | 24 ++++-- user-apps/wav_player/src/main.rs | 11 ++- 3 files changed, 139 insertions(+), 39 deletions(-) diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index 30c75e0..b5fc298 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -1,17 +1,17 @@ -use core::{ - sync::atomic::{AtomicBool, Ordering}, - time::Duration, -}; +use crate::Audio; +use core::sync::atomic::{AtomicBool, Ordering}; use embassy_rp::{ Peri, - pio::Pio, - pio_programs::pwm::{PioPwm, PioPwmProgram}, - pwm::{Config, Pwm, SetDutyCycle}, + dma::{AnyChannel, Channel}, + gpio::Level, + pio::{ + Common, Config, Direction, FifoJoin, Instance, LoadedProgram, PioPin, ShiftConfig, + ShiftDirection, StateMachine, program::pio_asm, + }, + pio_programs::clock_divider::calculate_pio_clock_divider, }; use embassy_time::Timer; -use crate::{Audio, Irqs}; - const AUDIO_BUFFER_LEN: usize = 1024; const _: () = assert!(AUDIO_BUFFER_LEN == abi_sys::AUDIO_BUFFER_LEN); pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_LEN] = [0; AUDIO_BUFFER_LEN]; @@ -19,34 +19,119 @@ static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_LEN] = [0; AUDIO_BUFFER_LEN]; pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true); -pub const SAMPLE_RATE_HZ: u32 = 22_050; +pub const SAMPLE_RATE_HZ: u32 = 8_000; #[embassy_executor::task] -pub async fn audio_handler(audio: Audio) { - let var_name = Pio::new(audio.pio_left, Irqs); - let Pio { - mut common, sm0, .. - } = var_name; +pub async fn audio_handler(mut audio: Audio) { + let prg = PioPwmAudioProgram8Bit::new(&mut audio.pio); + defmt::info!("loaded prg"); - let prg = PioPwmProgram::new(&mut common); - let mut pwm_pio = PioPwm::new(&mut common, sm0, audio.left, &prg); - - let period = Duration::from_nanos(1_000_000_000 / SAMPLE_RATE_HZ as u64); - pwm_pio.set_period(period); + let mut pwm_pio = PioPwmAudio::new(audio.dma, &mut audio.pio, audio.sm0, audio.left, &prg); + defmt::info!("cfgd sm"); + pwm_pio.configure(SAMPLE_RATE_HZ); pwm_pio.start(); - - let sample_interval = 1_000_000 / SAMPLE_RATE_HZ as u64; // in µs ≈ 45 µs - loop { - for &sample in unsafe { &AUDIO_BUFFER }.iter() { - let period_ns = period.as_nanos() as u32; - let duty_ns = period_ns * (sample as u32) / 255; - pwm_pio.write(Duration::from_nanos(duty_ns as u64)); - Timer::after_micros(sample_interval).await; // sample interval = 1 / sample rate - } + pwm_pio.write(unsafe { &AUDIO_BUFFER_1 }).await; unsafe { core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1) }; AUDIO_BUFFER_READY.store(true, Ordering::Release) } } + +struct PioPwmAudioProgram8Bit<'d, PIO: Instance>(LoadedProgram<'d, PIO>); + +impl<'d, PIO: Instance> PioPwmAudioProgram8Bit<'d, PIO> { + fn new(common: &mut Common<'d, PIO>) -> Self { + let prg = pio_asm!( + "out x, 8", // samples << + "out y, 8", // samples max >> + "loop_high:", + "set pins, 1", // keep pin high + "jmp x-- loop_high", // decrement X until 0 + "loop_low:", + "set pins, 0", // keep pin low + "jmp y-- loop_low", // decrement Y until 0 + ); + + let prg = common.load_program(&prg.program); + + Self(prg) + } +} + +struct PioPwmAudio<'d, PIO: Instance, const SM: usize> { + dma: Peri<'d, AnyChannel>, + cfg: Config<'d, PIO>, + sm: StateMachine<'d, PIO, SM>, +} + +impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> { + fn new( + dma: Peri<'d, impl Channel>, + pio: &mut Common<'d, PIO>, + mut sm: StateMachine<'d, PIO, SM>, + pin: Peri<'d, impl PioPin>, + prg: &PioPwmAudioProgram8Bit<'d, PIO>, + ) -> Self { + let pin = pio.make_pio_pin(pin); + sm.set_pins(Level::High, &[&pin]); + sm.set_pin_dirs(Direction::Out, &[&pin]); + + let mut cfg = Config::default(); + cfg.set_set_pins(&[&pin]); + cfg.fifo_join = FifoJoin::TxOnly; + let mut shift_cfg = ShiftConfig::default(); + shift_cfg.auto_fill = true; + cfg.shift_out = shift_cfg; + cfg.use_program(&prg.0, &[]); + sm.set_config(&cfg); + + Self { + dma: dma.into(), + cfg, + sm, + } + } + + fn configure(&mut self, sample_rate: u32) { + let cycles_per_sample = u8::MAX as u32 + 2; // X_max + Y_max + movs + let target_pio_hz = cycles_per_sample * sample_rate; // ~11.3 MHz + + let divider = calculate_pio_clock_divider(target_pio_hz); + self.cfg.clock_divider = divider; + self.sm.set_clock_divider(divider); + } + + async fn write(&mut self, buf: &[u8]) { + let mut packed_buf = [0_u32; AUDIO_BUFFER_LEN / 4]; + + for (packed_sample, sample) in packed_buf.iter_mut().zip(buf.chunks(2)) { + *packed_sample = pack_two_samples(sample[0], sample[1]); + } + + self.sm + .tx() + .dma_push(self.dma.reborrow(), &packed_buf, false) + .await + } + + fn start(&mut self) { + self.sm.set_enable(true); + } + + fn stop(&mut self) { + self.sm.set_enable(false); + } +} + +fn pack_two_samples(s1: u8, s2: u8) -> u32 { + let x = ((s1 as u16) << 8 | (255 - s1) as u16); // original + let y = ((s2 as u16) << 8 | (255 - s2) as u16); + + // Scale to full 16-bit for higher volume: + let x_scaled = ((x as u32) << 8) | (x as u32 >> 8); + let y_scaled = ((y as u32) << 8) | (y as u32 >> 8); + + (x_scaled << 16) | y_scaled +} diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 48fb3d6..aedc590 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -49,11 +49,10 @@ use embassy_rp::{ 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, PIN_26, PIN_27, PIO0, PIO1, PWM_SLICE5, SPI0, SPI1, - USB, + DMA_CH0, DMA_CH1, DMA_CH3, 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, PIN_26, PIN_27, PIO0, SPI0, SPI1, USB, }, - pio, + pio::{self, Common, Pio, StateMachine}, spi::{self, Spi}, usb as embassy_rp_usb, }; @@ -110,9 +109,15 @@ async fn main(_spawner: Spawner) { data: p.PIN_14, reset: p.PIN_15, }; + let Pio { + common, sm0, sm1, .. + } = Pio::new(p.PIO0, Irqs); + let audio = Audio { - pio_left: p.PIO0, - pio_right: p.PIO1, + dma: p.DMA_CH3, + pio: common, + sm0, + sm1, left: p.PIN_26, right: p.PIN_27, }; @@ -182,8 +187,10 @@ struct Display { reset: Peri<'static, PIN_15>, } struct Audio { - pio_left: Peri<'static, PIO0>, - pio_right: Peri<'static, PIO1>, + dma: Peri<'static, DMA_CH3>, + pio: Common<'static, PIO0>, + sm0: StateMachine<'static, PIO0, 0>, + sm1: StateMachine<'static, PIO0, 1>, left: Peri<'static, PIN_26>, right: Peri<'static, PIN_27>, } @@ -250,7 +257,6 @@ async fn kernel_task( usb: Peri<'static, USB>, ) { setup_mcu(mcu).await; - Timer::after_millis(250).await; setup_display(display, spawner).await; setup_sd(sd).await; diff --git a/user-apps/wav_player/src/main.rs b/user-apps/wav_player/src/main.rs index 3a970b5..3dafe70 100644 --- a/user-apps/wav_player/src/main.rs +++ b/user-apps/wav_player/src/main.rs @@ -41,9 +41,17 @@ pub fn main() { wav.restart().unwrap() } - wav.read(&mut buf).unwrap(); + let read = wav.read(&mut buf).unwrap(); send_audio_buffer(&buf); } + + let event = get_key(); + if event.state != KeyState::Idle { + match event.key { + KeyCode::Esc => return, + _ => (), + } + } } } @@ -64,6 +72,7 @@ impl File { impl PlatformFile for File { fn read(&mut self, buf: &mut [u8]) -> Result { let read = read_file(&self.file, self.current_pos, buf); + self.current_pos += read; Ok(read) } From 7efea9eb8d605522a451031a14e73e41c5d4907e Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 10:25:46 -0700 Subject: [PATCH 03/19] fix justfile --- justfile | 1 + 1 file changed, 1 insertion(+) diff --git a/justfile b/justfile index 50dd42f..ccddf36 100644 --- a/justfile +++ b/justfile @@ -51,6 +51,7 @@ copy-userapps: just copy-userapp snake just copy-userapp gallery just copy-userapp gif + just copy-userapp wav_player DEV=$(lsblk -o LABEL,NAME -nr | awk -v L="PICOCALC" '$1==L {print "/dev/" $2}') udisksctl unmount -b "$DEV" From 8c208643929884de6303fa6b38f3ad707edb8b11 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 14:52:47 -0700 Subject: [PATCH 04/19] audio works --- Cargo.lock | 1 + abi/src/lib.rs | 2 +- abi_sys/src/lib.rs | 3 +- kernel/Cargo.toml | 3 +- kernel/src/abi.rs | 14 +++- kernel/src/audio.rs | 129 +++++++++++++++++-------------- kernel/src/main.rs | 14 ++-- user-apps/wav_player/src/main.rs | 5 +- 8 files changed, 100 insertions(+), 71 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 24d9dfa..097fc7f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1478,6 +1478,7 @@ dependencies = [ "embedded-layout", "embedded-sdmmc", "embedded-text", + "fixed", "goblin", "heapless", "micromath", diff --git a/abi/src/lib.rs b/abi/src/lib.rs index 7bd1b2d..18f453a 100644 --- a/abi/src/lib.rs +++ b/abi/src/lib.rs @@ -269,7 +269,7 @@ pub mod fs { } pub mod audio { - pub use abi_sys::{AUDIO_BUFFER_LEN, audio_buffer_ready}; + pub use abi_sys::{AUDIO_BUFFER_LEN, AUDIO_BUFFER_SAMPLES, audio_buffer_ready}; pub fn send_audio_buffer(buf: &[u8]) { abi_sys::send_audio_buffer(buf.as_ptr(), buf.len()) diff --git a/abi_sys/src/lib.rs b/abi_sys/src/lib.rs index 82f2f6e..0b26e9f 100644 --- a/abi_sys/src/lib.rs +++ b/abi_sys/src/lib.rs @@ -481,7 +481,8 @@ pub fn audio_buffer_ready() -> bool { } } -pub const AUDIO_BUFFER_LEN: usize = 1024; +pub const AUDIO_BUFFER_SAMPLES: usize = 1024; +pub const AUDIO_BUFFER_LEN: usize = AUDIO_BUFFER_SAMPLES * 2; pub type SendAudioBuffer = extern "C" fn(ptr: *const u8, len: usize); diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 8293a53..aae1192 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -82,6 +82,8 @@ embedded-graphics = { version = "0.8.1" } embedded-text = "0.7.2" embedded-layout = "0.4.2" +micromath = "2.1.0" +fixed = "1.29.0" strum = { version = "0.27.2", default-features = false } rand = { version = "0.9.0", default-features = false } once_cell = { version = "1.21.3", default-features = false } @@ -98,4 +100,3 @@ embedded-alloc = { version = "0.6.0", features = [ bumpalo = "3.19.0" abi_sys = { path = "../abi_sys" } -micromath = "2.1.0" diff --git a/kernel/src/abi.rs b/kernel/src/abi.rs index 6254934..8f77bd7 100644 --- a/kernel/src/abi.rs +++ b/kernel/src/abi.rs @@ -1,5 +1,5 @@ use abi_sys::{ - AUDIO_BUFFER_LEN, AllocAbi, AudioBufferReady, CLayout, CPixel, DeallocAbi, DrawIterAbi, + AUDIO_BUFFER_SAMPLES, AllocAbi, AudioBufferReady, CLayout, CPixel, DeallocAbi, DrawIterAbi, FileLen, GenRand, GetMsAbi, ListDir, PrintAbi, ReadFile, RngRequest, SendAudioBuffer, SleepMsAbi, WriteFile, keyboard::*, }; @@ -209,7 +209,6 @@ fn recurse_file( dirs: &[&str], mut access: impl FnMut(&mut File) -> T, ) -> Result { - defmt::info!("dir: {}, dirs: {}", dir, dirs); if dirs.len() == 1 { let mut b = [0_u8; 50]; let mut buf = LfnBuffer::new(&mut b); @@ -346,8 +345,15 @@ pub extern "C" fn send_audio_buffer(ptr: *const u8, len: usize) { while !AUDIO_BUFFER_READY.load(Ordering::Acquire) {} - if buf.len() == AUDIO_BUFFER_LEN { + if buf.len() == AUDIO_BUFFER_SAMPLES * 2 { + AUDIO_BUFFER_READY.store(false, Ordering::Release); unsafe { AUDIO_BUFFER.copy_from_slice(buf) }; - AUDIO_BUFFER_READY.store(false, Ordering::Release) + } else { + #[cfg(feature = "defmt")] + defmt::warn!( + "user audio stream was wrong size: {} should be {}", + buf.len(), + AUDIO_BUFFER_SAMPLES * 2 + ) } } diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index b5fc298..917f806 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -1,51 +1,92 @@ use crate::Audio; use core::sync::atomic::{AtomicBool, Ordering}; +use embassy_futures::join::join; use embassy_rp::{ Peri, + clocks::clk_sys_freq, dma::{AnyChannel, Channel}, gpio::Level, pio::{ Common, Config, Direction, FifoJoin, Instance, LoadedProgram, PioPin, ShiftConfig, - ShiftDirection, StateMachine, program::pio_asm, + StateMachine, program::pio_asm, }, pio_programs::clock_divider::calculate_pio_clock_divider, }; -use embassy_time::Timer; +use fixed::traits::ToFixed; -const AUDIO_BUFFER_LEN: usize = 1024; -const _: () = assert!(AUDIO_BUFFER_LEN == abi_sys::AUDIO_BUFFER_LEN); -pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_LEN] = [0; AUDIO_BUFFER_LEN]; -static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_LEN] = [0; AUDIO_BUFFER_LEN]; +pub const SAMPLE_RATE_HZ: u32 = 22_050; +const AUDIO_BUFFER_SAMPLES: usize = 1024; +const _: () = assert!(AUDIO_BUFFER_SAMPLES == abi_sys::AUDIO_BUFFER_SAMPLES); + +// 8bit stereo interleaved PCM audio buffers +pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [0; AUDIO_BUFFER_SAMPLES * 2]; +static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [0; AUDIO_BUFFER_SAMPLES * 2]; pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true); -pub const SAMPLE_RATE_HZ: u32 = 8_000; - #[embassy_executor::task] pub async fn audio_handler(mut audio: Audio) { + const SILENCE_VALUE: u8 = u8::MAX / 2; + let prg = PioPwmAudioProgram8Bit::new(&mut audio.pio); - defmt::info!("loaded prg"); + let mut pwm_pio_left = + PioPwmAudio::new(audio.dma0, &mut audio.pio, audio.sm0, audio.left, &prg); + let mut pwm_pio_right = + PioPwmAudio::new(audio.dma1, &mut audio.pio, audio.sm1, audio.right, &prg); - let mut pwm_pio = PioPwmAudio::new(audio.dma, &mut audio.pio, audio.sm0, audio.left, &prg); - defmt::info!("cfgd sm"); - - pwm_pio.configure(SAMPLE_RATE_HZ); - pwm_pio.start(); loop { - pwm_pio.write(unsafe { &AUDIO_BUFFER_1 }).await; + write_samples(&mut pwm_pio_left, &mut pwm_pio_right, unsafe { + &AUDIO_BUFFER_1 + }) + .await; + unsafe { &mut AUDIO_BUFFER_1 }.fill(SILENCE_VALUE); unsafe { core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1) }; AUDIO_BUFFER_READY.store(true, Ordering::Release) } } +async fn write_samples( + left: &mut PioPwmAudio<'static, PIO, 0>, + right: &mut PioPwmAudio<'static, PIO, 1>, + buf: &[u8], +) { + // pack two samples per word + let mut packed_buf_left: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2]; + let mut packed_buf_right: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2]; + + for ((pl, pr), sample) in packed_buf_left + .iter_mut() + .zip(packed_buf_right.iter_mut()) + .zip(buf.chunks(4)) + { + *pl = pack_u8_samples(sample[0], sample[2]); + *pr = pack_u8_samples(sample[1], sample[3]); + } + + let left_fut = left + .sm + .tx() + .dma_push(left.dma.reborrow(), &packed_buf_left, false); + + let right_fut = right + .sm + .tx() + .dma_push(right.dma.reborrow(), &packed_buf_right, false); + + join(left_fut, right_fut).await; +} + struct PioPwmAudioProgram8Bit<'d, PIO: Instance>(LoadedProgram<'d, PIO>); +/// Writes one sample to pwm as high and low time impl<'d, PIO: Instance> PioPwmAudioProgram8Bit<'d, PIO> { fn new(common: &mut Common<'d, PIO>) -> Self { + // only uses 16 bits top for high, bottom for low + // allows two samples per word let prg = pio_asm!( - "out x, 8", // samples << - "out y, 8", // samples max >> + "out x, 8", // pwm high time + "out y, 8", // pwm low time "loop_high:", "set pins, 1", // keep pin high "jmp x-- loop_high", // decrement X until 0 @@ -62,7 +103,6 @@ impl<'d, PIO: Instance> PioPwmAudioProgram8Bit<'d, PIO> { struct PioPwmAudio<'d, PIO: Instance, const SM: usize> { dma: Peri<'d, AnyChannel>, - cfg: Config<'d, PIO>, sm: StateMachine<'d, PIO, SM>, } @@ -87,51 +127,24 @@ impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> { cfg.use_program(&prg.0, &[]); sm.set_config(&cfg); + let target_clock = (u8::MAX as u32 + 1) * SAMPLE_RATE_HZ; + let divider = (clk_sys_freq() / (target_clock * 2)).to_fixed(); + sm.set_clock_divider(divider); + + sm.set_enable(true); + Self { dma: dma.into(), - cfg, sm, } } - - fn configure(&mut self, sample_rate: u32) { - let cycles_per_sample = u8::MAX as u32 + 2; // X_max + Y_max + movs - let target_pio_hz = cycles_per_sample * sample_rate; // ~11.3 MHz - - let divider = calculate_pio_clock_divider(target_pio_hz); - self.cfg.clock_divider = divider; - self.sm.set_clock_divider(divider); - } - - async fn write(&mut self, buf: &[u8]) { - let mut packed_buf = [0_u32; AUDIO_BUFFER_LEN / 4]; - - for (packed_sample, sample) in packed_buf.iter_mut().zip(buf.chunks(2)) { - *packed_sample = pack_two_samples(sample[0], sample[1]); - } - - self.sm - .tx() - .dma_push(self.dma.reborrow(), &packed_buf, false) - .await - } - - fn start(&mut self) { - self.sm.set_enable(true); - } - - fn stop(&mut self) { - self.sm.set_enable(false); - } } -fn pack_two_samples(s1: u8, s2: u8) -> u32 { - let x = ((s1 as u16) << 8 | (255 - s1) as u16); // original - let y = ((s2 as u16) << 8 | (255 - s2) as u16); - - // Scale to full 16-bit for higher volume: - let x_scaled = ((x as u32) << 8) | (x as u32 >> 8); - let y_scaled = ((y as u32) << 8) | (y as u32 >> 8); - - (x_scaled << 16) | y_scaled +/// packs two u8 samples into 32bit word +fn pack_u8_samples(sample1: u8, sample2: u8) -> u32 { + (u8_pcm_to_pwm(sample1) as u32) << 16 | u8_pcm_to_pwm(sample2) as u32 +} + +fn u8_pcm_to_pwm(sample: u8) -> u16 { + ((sample as u16) << 8) | ((u8::MAX - sample) as u16) } diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 107e332..b1a6efc 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -121,10 +121,12 @@ async fn watchdog_task(mut watchdog: Watchdog) { static ENABLE_UI: AtomicBool = AtomicBool::new(true); static UI_CHANGE: Signal = Signal::new(); +const OVERCLOCK: u32 = 300_000_000; + #[embassy_executor::main] async fn main(_spawner: Spawner) { let p = if cfg!(feature = "overclock") { - let clocks = ClockConfig::system_freq(300_000_000).unwrap(); + let clocks = ClockConfig::system_freq(OVERCLOCK).unwrap(); let config = Config::new(clocks); embassy_rp::init(config) } else { @@ -156,11 +158,12 @@ async fn main(_spawner: Spawner) { } = Pio::new(p.PIO0, Irqs); let audio = Audio { - dma: p.DMA_CH3, pio: common, sm0, - sm1, + dma0: p.DMA_CH3, left: p.PIN_26, + sm1, + dma1: p.DMA_CH4, right: p.PIN_27, }; let sd = Sd { @@ -244,11 +247,12 @@ struct Display { reset: Peri<'static, PIN_15>, } struct Audio { - dma: Peri<'static, DMA_CH3>, pio: Common<'static, PIO0>, + dma0: Peri<'static, DMA_CH3>, sm0: StateMachine<'static, PIO0, 0>, - sm1: StateMachine<'static, PIO0, 1>, left: Peri<'static, PIN_26>, + dma1: Peri<'static, DMA_CH4>, + sm1: StateMachine<'static, PIO0, 1>, right: Peri<'static, PIN_27>, } struct Sd { diff --git a/user-apps/wav_player/src/main.rs b/user-apps/wav_player/src/main.rs index 46d3277..c662038 100644 --- a/user-apps/wav_player/src/main.rs +++ b/user-apps/wav_player/src/main.rs @@ -33,6 +33,9 @@ pub fn main() { let file = File::new(String::from("/music/test.wav")); let mut wav = Wav::new(file).unwrap(); + println!("sample rate: {}", wav.sample_rate()); + println!("channels: {:?}", wav.channels() as u8); + loop { if audio_buffer_ready() { if wav.is_eof() { @@ -44,7 +47,7 @@ pub fn main() { } let event = get_key(); - if event.state != KeyState::Idle { + if event.state == KeyState::Released { match event.key { KeyCode::Esc => return, _ => (), From 0e7e330998975382657287eed5b54472379c8cd9 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 15:02:32 -0700 Subject: [PATCH 05/19] selection ui for wav_player --- Cargo.lock | 1 + user-apps/wav_player/Cargo.toml | 1 + user-apps/wav_player/src/main.rs | 81 +++++++++++++++++++++++--------- 3 files changed, 61 insertions(+), 22 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 097fc7f..3dce1b4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2762,6 +2762,7 @@ dependencies = [ "embedded-audio", "embedded-graphics", "rand", + "selection_ui", ] [[package]] diff --git a/user-apps/wav_player/Cargo.toml b/user-apps/wav_player/Cargo.toml index 85c67ac..37b1594 100644 --- a/user-apps/wav_player/Cargo.toml +++ b/user-apps/wav_player/Cargo.toml @@ -5,6 +5,7 @@ edition = "2024" [dependencies] abi = { path = "../../abi" } +selection_ui = { path = "../../selection_ui" } embedded-graphics = "0.8.1" rand = { version = "0.9.0", default-features = false } embedded-audio = { git = "https://github.com/LegitCamper/embedded-audio" } diff --git a/user-apps/wav_player/src/main.rs b/user-apps/wav_player/src/main.rs index c662038..66bee3c 100644 --- a/user-apps/wav_player/src/main.rs +++ b/user-apps/wav_player/src/main.rs @@ -5,14 +5,21 @@ extern crate alloc; use abi::{ audio::{AUDIO_BUFFER_LEN, audio_buffer_ready, send_audio_buffer}, display::Display, - fs::{file_len, read_file}, + format, + fs::{Entries, file_len, list_dir, read_file}, get_key, keyboard::{KeyCode, KeyState}, println, }; -use alloc::string::String; +use alloc::{string::String, vec::Vec}; use core::panic::PanicInfo; use embedded_audio::{AudioFile, PlatformFile, PlatformFileError, wav::Wav}; +use embedded_graphics::{ + mono_font::{MonoTextStyle, ascii::FONT_6X10}, + pixelcolor::Rgb565, + prelude::RgbColor, +}; +use selection_ui::{SelectionUi, SelectionUiError, draw_text_center}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { @@ -27,30 +34,60 @@ pub extern "Rust" fn _start() { pub fn main() { println!("Starting Wav player app"); - let mut _display = Display::take(); - - let mut buf = [0_u8; AUDIO_BUFFER_LEN]; - - let file = File::new(String::from("/music/test.wav")); - let mut wav = Wav::new(file).unwrap(); - println!("sample rate: {}", wav.sample_rate()); - println!("channels: {:?}", wav.channels() as u8); + let mut display = Display::take().unwrap(); loop { - if audio_buffer_ready() { - if wav.is_eof() { - wav.restart().unwrap() + let mut entries = Entries::new(); + list_dir("/music", &mut entries); + + let mut files = entries.entries(); + files.retain(|e| e.extension().unwrap_or("") == "wav"); + let mut wavs = files.iter().map(|e| e.full_name()).collect::>(); + wavs.sort(); + + let mut selection_ui = SelectionUi::new(&mut wavs); + let selection = match selection_ui.run_selection_ui(&mut display) { + Ok(maybe_sel) => maybe_sel, + Err(e) => match e { + SelectionUiError::SelectionListEmpty => { + draw_text_center( + &mut display, + "No Wavs were found in /gifs", + MonoTextStyle::new(&FONT_6X10, Rgb565::RED), + ) + .expect("Display Error"); + None + } + SelectionUiError::DisplayError(_) => panic!("Display Error"), + }, + }; + + assert!(selection.is_some()); + + let file_name = format!("/music/{}", wavs[selection.unwrap()]); + let file = File::new(String::from(file_name)); + let mut wav = Wav::new(file).unwrap(); + println!("sample rate: {}", wav.sample_rate()); + println!("channels: {:?}", wav.channels() as u8); + + let mut buf = [0_u8; AUDIO_BUFFER_LEN]; + + loop { + if audio_buffer_ready() { + if wav.is_eof() { + break; + } + + let _read = wav.read(&mut buf).unwrap(); + send_audio_buffer(&buf); } - let _read = wav.read(&mut buf).unwrap(); - send_audio_buffer(&buf); - } - - let event = get_key(); - if event.state == KeyState::Released { - match event.key { - KeyCode::Esc => return, - _ => (), + let event = get_key(); + if event.state == KeyState::Released { + match event.key { + KeyCode::Esc => return, + _ => (), + } } } } From 90d32f050cceb68010924a99083338995aaf2115 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 15:07:04 -0700 Subject: [PATCH 06/19] remove uneeded --- kernel/src/audio.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index 917f806..7b883dc 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -10,7 +10,6 @@ use embassy_rp::{ Common, Config, Direction, FifoJoin, Instance, LoadedProgram, PioPin, ShiftConfig, StateMachine, program::pio_asm, }, - pio_programs::clock_divider::calculate_pio_clock_divider, }; use fixed::traits::ToFixed; From 39ced811c3b51e1c1e9c927b873fdcf6a2d946e1 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 15:15:39 -0700 Subject: [PATCH 07/19] yield display to audio --- kernel/src/display.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/kernel/src/display.rs b/kernel/src/display.rs index 86c693f..568e441 100644 --- a/kernel/src/display.rs +++ b/kernel/src/display.rs @@ -1,17 +1,15 @@ use crate::framebuffer::{self, AtomicFrameBuffer, FB_PAUSED}; use core::alloc::{GlobalAlloc, Layout}; use core::sync::atomic::Ordering; +use embassy_futures::yield_now; 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::{ - pixelcolor::Rgb565, - prelude::{DrawTarget, RgbColor}, -}; +use embassy_time::Delay; +use embedded_graphics::{draw_target::DrawTarget, pixelcolor::Rgb565, prelude::RgbColor}; use embedded_hal_bus::spi::ExclusiveDevice; use st7365p_lcd::ST7365P; @@ -117,7 +115,7 @@ pub async fn display_handler(mut display: DISPLAY) { if elapsed < FRAME_TIME_MS { Timer::after_millis(FRAME_TIME_MS - elapsed).await; } else { - Timer::after_millis(1).await; + yield_now().await; } } } From 55347be2323acc8161be67e3c1041b561e5b9232 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 16:13:33 -0700 Subject: [PATCH 08/19] show selected file --- kernel/src/main.rs | 5 +---- selection_ui/src/lib.rs | 8 +++++++- user-apps/wav_player/src/main.rs | 9 ++++++++- 3 files changed, 16 insertions(+), 6 deletions(-) diff --git a/kernel/src/main.rs b/kernel/src/main.rs index b1a6efc..d738dbf 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -34,10 +34,7 @@ use crate::{ abi::{KEY_CACHE, MS_SINCE_LAUNCH}, audio::audio_handler, display::{FRAMEBUFFER, display_handler, init_display}, - peripherals::{ - conf_peripherals, - keyboard::{KeyState, read_keyboard_fifo}, - }, + peripherals::{conf_peripherals, keyboard::read_keyboard_fifo}, scsi::MSC_SHUTDOWN, storage::{SDCARD, SdCard}, ui::{SELECTIONS, clear_selection, ui_handler}, diff --git a/selection_ui/src/lib.rs b/selection_ui/src/lib.rs index ac4e9ab..e21d533 100644 --- a/selection_ui/src/lib.rs +++ b/selection_ui/src/lib.rs @@ -144,5 +144,11 @@ pub fn draw_text_center<'a, S>( where S: TextRenderer::Color>, { - Text::with_alignment(text, Point::zero(), style, Alignment::Center).draw(display) + Text::with_alignment( + text, + display.bounding_box().center(), + style, + Alignment::Center, + ) + .draw(display) } diff --git a/user-apps/wav_player/src/main.rs b/user-apps/wav_player/src/main.rs index 66bee3c..b3605b4 100644 --- a/user-apps/wav_player/src/main.rs +++ b/user-apps/wav_player/src/main.rs @@ -52,7 +52,7 @@ pub fn main() { SelectionUiError::SelectionListEmpty => { draw_text_center( &mut display, - "No Wavs were found in /gifs", + "No Wavs were found in /music", MonoTextStyle::new(&FONT_6X10, Rgb565::RED), ) .expect("Display Error"); @@ -64,6 +64,13 @@ pub fn main() { assert!(selection.is_some()); + draw_text_center( + &mut display, + &format!("Now playing {}", wavs[selection.unwrap()]), + MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE), + ) + .expect("Display Error"); + let file_name = format!("/music/{}", wavs[selection.unwrap()]); let file = File::new(String::from(file_name)); let mut wav = Wav::new(file).unwrap(); From d77320d445c0aa82278544e521eb1a209390be7e Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 16:37:02 -0700 Subject: [PATCH 09/19] rename libraries fix remove --- .gitignore | 2 +- Cargo.lock | 56 +++++++++---------- Cargo.toml | 14 ++--- README.md | 13 +++-- justfile | 2 +- kernel/Cargo.toml | 2 +- kernel/src/abi.rs | 12 ++-- kernel/src/audio.rs | 2 +- kernel/src/elf.rs | 2 +- kernel/src/main.rs | 2 +- kernel/src/peripherals/keyboard.rs | 2 +- kernel/src/ui.rs | 2 +- selection_ui/Cargo.toml | 2 +- selection_ui/src/lib.rs | 16 +++--- .../calculator/Cargo.toml | 2 +- {user-apps => user_apps}/calculator/build.rs | 0 .../calculator/src/main.rs | 12 ++-- {user-apps => user_apps}/gallery/Cargo.toml | 2 +- {user-apps => user_apps}/gallery/build.rs | 0 {user-apps => user_apps}/gallery/src/main.rs | 14 ++--- {user-apps => user_apps}/gif/Cargo.toml | 2 +- {user-apps => user_apps}/gif/build.rs | 0 {user-apps => user_apps}/gif/src/main.rs | 18 +++--- {user-apps => user_apps}/memory.x | 0 {user-apps => user_apps}/snake/Cargo.toml | 2 +- {user-apps => user_apps}/snake/build.rs | 0 {user-apps => user_apps}/snake/src/main.rs | 8 +-- .../wav_player/Cargo.toml | 2 +- {user-apps => user_apps}/wav_player/build.rs | 0 .../wav_player/src/main.rs | 24 ++++---- {abi => userlib}/Cargo.toml | 4 +- {abi => userlib}/src/lib.rs | 36 ++++++------ {abi_sys => userlib_sys}/Cargo.toml | 2 +- {abi_sys => userlib_sys}/src/lib.rs | 0 34 files changed, 129 insertions(+), 128 deletions(-) rename {user-apps => user_apps}/calculator/Cargo.toml (78%) rename {user-apps => user_apps}/calculator/build.rs (100%) rename {user-apps => user_apps}/calculator/src/main.rs (99%) rename {user-apps => user_apps}/gallery/Cargo.toml (77%) rename {user-apps => user_apps}/gallery/build.rs (100%) rename {user-apps => user_apps}/gallery/src/main.rs (99%) rename {user-apps => user_apps}/gif/Cargo.toml (85%) rename {user-apps => user_apps}/gif/build.rs (100%) rename {user-apps => user_apps}/gif/src/main.rs (93%) rename {user-apps => user_apps}/memory.x (100%) rename {user-apps => user_apps}/snake/Cargo.toml (86%) rename {user-apps => user_apps}/snake/build.rs (100%) rename {user-apps => user_apps}/snake/src/main.rs (99%) rename {user-apps => user_apps}/wav_player/Cargo.toml (88%) rename {user-apps => user_apps}/wav_player/build.rs (100%) rename {user-apps => user_apps}/wav_player/src/main.rs (91%) rename {abi => userlib}/Cargo.toml (73%) rename {abi => userlib}/src/lib.rs (88%) rename {abi_sys => userlib_sys}/Cargo.toml (94%) rename {abi_sys => userlib_sys}/src/lib.rs (100%) diff --git a/.gitignore b/.gitignore index 62db18b..573ce9b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,6 @@ /target *.uf2 -abi_sys.h +userlib_sys.h assets/gif/bad_apple.gif picolibc user-apps/gboy/Peanut-GB diff --git a/Cargo.lock b/Cargo.lock index 3dce1b4..a47adf1 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -12,27 +12,6 @@ dependencies = [ "regex", ] -[[package]] -name = "abi" -version = "0.1.0" -dependencies = [ - "abi_sys", - "embedded-graphics", - "once_cell", - "rand_core 0.9.3", -] - -[[package]] -name = "abi_sys" -version = "0.1.0" -dependencies = [ - "bitflags 2.10.0", - "cbindgen", - "defmt 0.3.100", - "embedded-graphics", - "strum", -] - [[package]] name = "ahash" version = "0.8.12" @@ -243,9 +222,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b" name = "calculator" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "embedded-layout", + "userlib", ] [[package]] @@ -1230,9 +1209,9 @@ dependencies = [ name = "gallery" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "tinybmp", + "userlib", ] [[package]] @@ -1272,10 +1251,10 @@ dependencies = [ name = "gif" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "selection_ui", "tinygif", + "userlib", ] [[package]] @@ -1450,7 +1429,6 @@ dependencies = [ name = "kernel" version = "0.0.1" dependencies = [ - "abi_sys", "assign-resources", "bitflags 2.10.0", "bt-hci", @@ -1493,6 +1471,7 @@ dependencies = [ "strum", "talc", "trouble-host", + "userlib_sys", ] [[package]] @@ -2157,10 +2136,10 @@ checksum = "c1257cd4248b4132760d6524d6dda4e053bc648c9070b960929bf50cfb1e7add" name = "selection_ui" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "embedded-layout", "embedded-text", + "userlib", ] [[package]] @@ -2271,10 +2250,10 @@ dependencies = [ name = "snake" version = "0.1.0" dependencies = [ - "abi", "embedded-graphics", "embedded-snake", "rand", + "userlib", ] [[package]] @@ -2647,6 +2626,27 @@ dependencies = [ "usbd-hid-descriptors", ] +[[package]] +name = "userlib" +version = "0.1.0" +dependencies = [ + "embedded-graphics", + "once_cell", + "rand_core 0.9.3", + "userlib_sys", +] + +[[package]] +name = "userlib_sys" +version = "0.1.0" +dependencies = [ + "bitflags 2.10.0", + "cbindgen", + "defmt 0.3.100", + "embedded-graphics", + "strum", +] + [[package]] name = "uuid" version = "1.18.1" @@ -2758,11 +2758,11 @@ dependencies = [ name = "wav_player" version = "0.1.0" dependencies = [ - "abi", "embedded-audio", "embedded-graphics", "rand", "selection_ui", + "userlib", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index 314eaf6..4973709 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -2,14 +2,14 @@ resolver = "3" members = [ "kernel", - "abi_sys", - "abi", + "userlib_sys", + "userlib", "selection_ui", - "user-apps/calculator", - "user-apps/snake", - "user-apps/gallery", - "user-apps/gif", - "user-apps/wav_player", + "user_apps/calculator", + "user_apps/snake", + "user_apps/gallery", + "user_apps/gif", + "user_apps/wav_player", ] [profile.release] diff --git a/README.md b/README.md index 2d4d4e0..15b7c77 100644 --- a/README.md +++ b/README.md @@ -6,21 +6,22 @@ This project provides a minimal kernel, ABI, and user-space applications to expe ## Status Basic synchronous applications are working great. -Current focus is on **expanding the ABI syscalls** and **fixing the MSC/USB-SCSI driver** to make application development easier and smoother. +Current focus is on exanding applications and porting software, finding bufs in ffi, and making sure the kernel is as stable as possible. ## Project Structure - **`kernel/`** – The core OS kernel (task scheduling, drivers, memory, etc.) -- **`abi_sys/`** – Shared application binary interface definitions for kernel ↔ userspace (Repr "C") -- **`abi/`** – Rust focused ABI helpers and abstractions for easier development -- **`user-apps/`** – Collection of userspace programs (calculator, snake, etc.) +- **`userlib_sys/`** – FFI bindings for kernel syscalls - kernel ↔ userspace (Repr "C") +- **`userlib/`** – Rust wrapper on top of `userlib_sys` +- **`picolib/`** – Built with ```just newlib```, and provides libc symbols when linking with C libraries +- **`user-apps/`** – Collection of userspace programs (gif player, wav player, calculator, snake, etc.) ## Features - Minimal Rust-based kernel targeting the PicoCalc -- Custom ABI for safe communication between kernel and applications +- Custom ABI for *Mostly* safe communication between kernel and applications - Support for multiple user-space applications -- Hardware drivers tailored for the PicoCalc +- Hardware drivers tailored for the PicoCalc( Audio, Display, Keyboard, ans Storage ) ## Getting Started diff --git a/justfile b/justfile index ccddf36..913f0b5 100644 --- a/justfile +++ b/justfile @@ -9,7 +9,7 @@ kernel-release board: binary-args := "RUSTFLAGS=\"-C link-arg=-pie -C relocation-model=pic\"" cbindgen: - cbindgen abi_sys --output abi_sys.h -q + cbindgen userlib_sys --output userlib_sys.h -q newlib: #!/bin/bash diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index aae1192..58f380c 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -99,4 +99,4 @@ embedded-alloc = { version = "0.6.0", features = [ ], optional = true } bumpalo = "3.19.0" -abi_sys = { path = "../abi_sys" } +userlib_sys = { path = "../userlib_sys" } diff --git a/kernel/src/abi.rs b/kernel/src/abi.rs index 8f77bd7..b5eec81 100644 --- a/kernel/src/abi.rs +++ b/kernel/src/abi.rs @@ -1,15 +1,15 @@ -use abi_sys::{ - AUDIO_BUFFER_SAMPLES, AllocAbi, AudioBufferReady, CLayout, CPixel, DeallocAbi, DrawIterAbi, - FileLen, GenRand, GetMsAbi, ListDir, PrintAbi, ReadFile, RngRequest, SendAudioBuffer, - SleepMsAbi, WriteFile, keyboard::*, -}; use alloc::{string::ToString, vec::Vec}; use core::{ffi::c_char, ptr, sync::atomic::Ordering}; -use embassy_rp::clocks::{RoscRng, clk_sys_freq}; +use embassy_rp::clocks::{clk_sys_freq, RoscRng}; use embassy_time::Instant; use embedded_graphics::draw_target::DrawTarget; use embedded_sdmmc::LfnBuffer; use heapless::spsc::Queue; +use userlib_sys::{ + keyboard::*, AllocAbi, AudioBufferReady, CLayout, CPixel, DeallocAbi, DrawIterAbi, FileLen, + GenRand, GetMsAbi, ListDir, PrintAbi, ReadFile, RngRequest, SendAudioBuffer, SleepMsAbi, + WriteFile, AUDIO_BUFFER_SAMPLES, +}; #[cfg(feature = "psram")] use crate::heap::HEAP; diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index 7b883dc..e26c939 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -15,7 +15,7 @@ use fixed::traits::ToFixed; pub const SAMPLE_RATE_HZ: u32 = 22_050; const AUDIO_BUFFER_SAMPLES: usize = 1024; -const _: () = assert!(AUDIO_BUFFER_SAMPLES == abi_sys::AUDIO_BUFFER_SAMPLES); +const _: () = assert!(AUDIO_BUFFER_SAMPLES == userlib_sys::AUDIO_BUFFER_SAMPLES); // 8bit stereo interleaved PCM audio buffers pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [0; AUDIO_BUFFER_SAMPLES * 2]; diff --git a/kernel/src/elf.rs b/kernel/src/elf.rs index 11e4855..05aba55 100644 --- a/kernel/src/elf.rs +++ b/kernel/src/elf.rs @@ -2,7 +2,7 @@ use crate::{ abi, storage::{File, SDCARD}, }; -use abi_sys::{CallTable, EntryFn}; +use userlib_sys::{CallTable, EntryFn}; use alloc::{vec, vec::Vec}; use bumpalo::Bump; use core::ptr; diff --git a/kernel/src/main.rs b/kernel/src/main.rs index d738dbf..f32bfca 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -39,7 +39,7 @@ use crate::{ storage::{SDCARD, SdCard}, ui::{SELECTIONS, clear_selection, ui_handler}, }; -use abi_sys::EntryFn; +use userlib_sys::EntryFn; use bumpalo::Bump; use core::sync::atomic::{AtomicBool, Ordering}; use embassy_executor::{Executor, Spawner}; diff --git a/kernel/src/peripherals/keyboard.rs b/kernel/src/peripherals/keyboard.rs index 28b65e7..77d60a8 100644 --- a/kernel/src/peripherals/keyboard.rs +++ b/kernel/src/peripherals/keyboard.rs @@ -1,5 +1,5 @@ use crate::peripherals::PERIPHERAL_BUS; -pub use abi_sys::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers}; +pub use userlib_sys::keyboard::{KeyCode, KeyEvent, KeyState, Modifiers}; const REG_ID_KEY: u8 = 0x04; const REG_ID_FIF: u8 = 0x09; diff --git a/kernel/src/ui.rs b/kernel/src/ui.rs index 2a304a9..6416276 100644 --- a/kernel/src/ui.rs +++ b/kernel/src/ui.rs @@ -2,7 +2,7 @@ use crate::{ BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED, peripherals::keyboard, storage::FileName, }; -use abi_sys::keyboard::{KeyCode, KeyState}; +use userlib_sys::keyboard::{KeyCode, KeyState}; use alloc::{str::FromStr, string::String, vec::Vec}; use core::sync::atomic::Ordering; use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex}; diff --git a/selection_ui/Cargo.toml b/selection_ui/Cargo.toml index 263d6e3..1aa0ac7 100644 --- a/selection_ui/Cargo.toml +++ b/selection_ui/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../abi" } +userlib = { path = "../userlib" } embedded-graphics = "0.8.1" embedded-layout = "0.4.2" embedded-text = "0.7.3" diff --git a/selection_ui/src/lib.rs b/selection_ui/src/lib.rs index e21d533..9844fce 100644 --- a/selection_ui/src/lib.rs +++ b/selection_ui/src/lib.rs @@ -2,25 +2,25 @@ extern crate alloc; -use abi::{ - display::Display, - get_key, - keyboard::{KeyCode, KeyState}, -}; use alloc::vec::Vec; use embedded_graphics::{ - Drawable, - mono_font::{MonoTextStyle, ascii::FONT_10X20}, + mono_font::{ascii::FONT_10X20, MonoTextStyle}, pixelcolor::Rgb565, prelude::{Dimensions, DrawTarget, Point, Primitive, RgbColor}, primitives::{PrimitiveStyle, Rectangle}, - text::{Alignment, Text, renderer::TextRenderer}, + text::{renderer::TextRenderer, Alignment, Text}, + Drawable, }; use embedded_layout::{ align::{horizontal, vertical}, layout::linear::{FixedMargin, LinearLayout}, prelude::*, }; +use userlib::{ + display::Display, + get_key, + keyboard::{KeyCode, KeyState}, +}; #[derive(Debug)] pub enum SelectionUiError { diff --git a/user-apps/calculator/Cargo.toml b/user_apps/calculator/Cargo.toml similarity index 78% rename from user-apps/calculator/Cargo.toml rename to user_apps/calculator/Cargo.toml index 19115f3..8d210d1 100644 --- a/user-apps/calculator/Cargo.toml +++ b/user_apps/calculator/Cargo.toml @@ -4,6 +4,6 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } embedded-graphics = "0.8.1" embedded-layout = "0.4.2" diff --git a/user-apps/calculator/build.rs b/user_apps/calculator/build.rs similarity index 100% rename from user-apps/calculator/build.rs rename to user_apps/calculator/build.rs diff --git a/user-apps/calculator/src/main.rs b/user_apps/calculator/src/main.rs similarity index 99% rename from user-apps/calculator/src/main.rs rename to user_apps/calculator/src/main.rs index 0b42eb9..fe559c7 100644 --- a/user-apps/calculator/src/main.rs +++ b/user_apps/calculator/src/main.rs @@ -2,12 +2,6 @@ #![no_main] extern crate alloc; -use abi::{ - display::Display, - get_key, - keyboard::{KeyCode, KeyState}, - println, -}; use alloc::{format, string::String, vec, vec::Vec}; use core::panic::PanicInfo; use embedded_graphics::{ @@ -25,6 +19,12 @@ use embedded_layout::{ layout::linear::LinearLayout, prelude::Chain, }; +use userlib::{ + display::Display, + get_key, + keyboard::{KeyCode, KeyState}, + println, +}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { diff --git a/user-apps/gallery/Cargo.toml b/user_apps/gallery/Cargo.toml similarity index 77% rename from user-apps/gallery/Cargo.toml rename to user_apps/gallery/Cargo.toml index 610805a..f9f06f7 100644 --- a/user-apps/gallery/Cargo.toml +++ b/user_apps/gallery/Cargo.toml @@ -4,6 +4,6 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } embedded-graphics = "0.8.1" tinybmp = "0.6.0" diff --git a/user-apps/gallery/build.rs b/user_apps/gallery/build.rs similarity index 100% rename from user-apps/gallery/build.rs rename to user_apps/gallery/build.rs diff --git a/user-apps/gallery/src/main.rs b/user_apps/gallery/src/main.rs similarity index 99% rename from user-apps/gallery/src/main.rs rename to user_apps/gallery/src/main.rs index 17c5dfc..35c9e34 100644 --- a/user-apps/gallery/src/main.rs +++ b/user_apps/gallery/src/main.rs @@ -3,13 +3,6 @@ #![allow(static_mut_refs)] extern crate alloc; -use abi::{ - display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, - fs::{Entries, list_dir, read_file}, - get_key, - keyboard::{KeyCode, KeyState}, - println, -}; use alloc::{format, vec}; use core::panic::PanicInfo; use embedded_graphics::{ @@ -17,6 +10,13 @@ use embedded_graphics::{ pixelcolor::Rgb565, prelude::*, text::Text, }; use tinybmp::Bmp; +use userlib::{ + display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, + fs::{Entries, list_dir, read_file}, + get_key, + keyboard::{KeyCode, KeyState}, + println, +}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { diff --git a/user-apps/gif/Cargo.toml b/user_apps/gif/Cargo.toml similarity index 85% rename from user-apps/gif/Cargo.toml rename to user_apps/gif/Cargo.toml index cc45976..fb9d4bd 100644 --- a/user-apps/gif/Cargo.toml +++ b/user_apps/gif/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } selection_ui = { path = "../../selection_ui" } embedded-graphics = "0.8.1" tinygif = { git = "https://github.com/LegitCamper/tinygif" } diff --git a/user-apps/gif/build.rs b/user_apps/gif/build.rs similarity index 100% rename from user-apps/gif/build.rs rename to user_apps/gif/build.rs diff --git a/user-apps/gif/src/main.rs b/user_apps/gif/src/main.rs similarity index 93% rename from user-apps/gif/src/main.rs rename to user_apps/gif/src/main.rs index e449096..0e263b8 100644 --- a/user-apps/gif/src/main.rs +++ b/user_apps/gif/src/main.rs @@ -2,24 +2,24 @@ #![no_main] extern crate alloc; -use abi::{ - display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, - fs::{Entries, file_len, list_dir, read_file}, - get_key, get_ms, - keyboard::{KeyCode, KeyState}, - println, sleep, -}; use alloc::{format, vec, vec::Vec}; use core::panic::PanicInfo; use embedded_graphics::{ image::ImageDrawable, - mono_font::{MonoTextStyle, ascii::FONT_6X10}, + mono_font::{ascii::FONT_6X10, MonoTextStyle}, pixelcolor::Rgb565, prelude::{Point, RgbColor}, transform::Transform, }; -use selection_ui::{SelectionUi, SelectionUiError, draw_text_center}; +use selection_ui::{draw_text_center, SelectionUi, SelectionUiError}; use tinygif::Gif; +use userlib::{ + display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, + fs::{file_len, list_dir, read_file, Entries}, + get_key, get_ms, + keyboard::{KeyCode, KeyState}, + println, sleep, +}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { diff --git a/user-apps/memory.x b/user_apps/memory.x similarity index 100% rename from user-apps/memory.x rename to user_apps/memory.x diff --git a/user-apps/snake/Cargo.toml b/user_apps/snake/Cargo.toml similarity index 86% rename from user-apps/snake/Cargo.toml rename to user_apps/snake/Cargo.toml index 7eb0d67..7d1a6ae 100644 --- a/user-apps/snake/Cargo.toml +++ b/user_apps/snake/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } embedded-graphics = "0.8.1" embedded-snake = { git = "https://github.com/LegitCamper/embedded-snake-rs" } rand = { version = "0.9.0", default-features = false } diff --git a/user-apps/snake/build.rs b/user_apps/snake/build.rs similarity index 100% rename from user-apps/snake/build.rs rename to user_apps/snake/build.rs diff --git a/user-apps/snake/src/main.rs b/user_apps/snake/src/main.rs similarity index 99% rename from user-apps/snake/src/main.rs rename to user_apps/snake/src/main.rs index a1e078a..2beda43 100644 --- a/user-apps/snake/src/main.rs +++ b/user_apps/snake/src/main.rs @@ -2,16 +2,16 @@ #![no_main] extern crate alloc; -use abi::{ +use core::panic::PanicInfo; +use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor}; +use embedded_snake::{Direction, SnakeGame}; +use userlib::{ Rng, display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, get_key, keyboard::{KeyCode, KeyState}, println, sleep, }; -use core::panic::PanicInfo; -use embedded_graphics::{pixelcolor::Rgb565, prelude::RgbColor}; -use embedded_snake::{Direction, SnakeGame}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { diff --git a/user-apps/wav_player/Cargo.toml b/user_apps/wav_player/Cargo.toml similarity index 88% rename from user-apps/wav_player/Cargo.toml rename to user_apps/wav_player/Cargo.toml index 37b1594..ca309d7 100644 --- a/user-apps/wav_player/Cargo.toml +++ b/user_apps/wav_player/Cargo.toml @@ -4,7 +4,7 @@ version = "0.1.0" edition = "2024" [dependencies] -abi = { path = "../../abi" } +userlib = { path = "../../userlib" } selection_ui = { path = "../../selection_ui" } embedded-graphics = "0.8.1" rand = { version = "0.9.0", default-features = false } diff --git a/user-apps/wav_player/build.rs b/user_apps/wav_player/build.rs similarity index 100% rename from user-apps/wav_player/build.rs rename to user_apps/wav_player/build.rs diff --git a/user-apps/wav_player/src/main.rs b/user_apps/wav_player/src/main.rs similarity index 91% rename from user-apps/wav_player/src/main.rs rename to user_apps/wav_player/src/main.rs index b3605b4..8a94659 100644 --- a/user-apps/wav_player/src/main.rs +++ b/user_apps/wav_player/src/main.rs @@ -2,24 +2,24 @@ #![no_main] extern crate alloc; -use abi::{ - audio::{AUDIO_BUFFER_LEN, audio_buffer_ready, send_audio_buffer}, +use alloc::{string::String, vec::Vec}; +use core::panic::PanicInfo; +use embedded_audio::{wav::Wav, AudioFile, PlatformFile, PlatformFileError}; +use embedded_graphics::{ + mono_font::{ascii::FONT_6X10, MonoTextStyle}, + pixelcolor::Rgb565, + prelude::RgbColor, +}; +use selection_ui::{draw_text_center, SelectionUi, SelectionUiError}; +use userlib::{ + audio::{audio_buffer_ready, send_audio_buffer, AUDIO_BUFFER_LEN}, display::Display, format, - fs::{Entries, file_len, list_dir, read_file}, + fs::{file_len, list_dir, read_file, Entries}, get_key, keyboard::{KeyCode, KeyState}, println, }; -use alloc::{string::String, vec::Vec}; -use core::panic::PanicInfo; -use embedded_audio::{AudioFile, PlatformFile, PlatformFileError, wav::Wav}; -use embedded_graphics::{ - mono_font::{MonoTextStyle, ascii::FONT_6X10}, - pixelcolor::Rgb565, - prelude::RgbColor, -}; -use selection_ui::{SelectionUi, SelectionUiError, draw_text_center}; #[panic_handler] fn panic(info: &PanicInfo) -> ! { diff --git a/abi/Cargo.toml b/userlib/Cargo.toml similarity index 73% rename from abi/Cargo.toml rename to userlib/Cargo.toml index 591ddaa..7555aa3 100644 --- a/abi/Cargo.toml +++ b/userlib/Cargo.toml @@ -1,10 +1,10 @@ [package] -name = "abi" +name = "userlib" version = "0.1.0" edition = "2024" [dependencies] -abi_sys = { path = "../abi_sys" } +userlib_sys = { path = "../userlib_sys" } embedded-graphics = "0.8.1" once_cell = { version = "1", default-features = false } rand_core = "0.9.3" diff --git a/abi/src/lib.rs b/userlib/src/lib.rs similarity index 88% rename from abi/src/lib.rs rename to userlib/src/lib.rs index 18f453a..43aad4a 100644 --- a/abi/src/lib.rs +++ b/userlib/src/lib.rs @@ -3,11 +3,11 @@ extern crate alloc; -use abi_sys::{RngRequest, keyboard::KeyEvent}; -pub use abi_sys::{keyboard, print}; pub use alloc::format; use core::alloc::{GlobalAlloc, Layout}; use rand_core::RngCore; +pub use userlib_sys::{keyboard, print}; +use userlib_sys::{keyboard::KeyEvent, RngRequest}; #[global_allocator] static ALLOC: Alloc = Alloc; @@ -16,11 +16,11 @@ struct Alloc; unsafe impl GlobalAlloc for Alloc { unsafe fn alloc(&self, layout: Layout) -> *mut u8 { - abi_sys::alloc(layout.into()) + userlib_sys::alloc(layout.into()) } unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { - abi_sys::dealloc(ptr, layout.into()); + userlib_sys::dealloc(ptr, layout.into()); } } @@ -33,28 +33,28 @@ macro_rules! println { } pub fn sleep(ms: u64) { - abi_sys::sleep(ms); + userlib_sys::sleep(ms); } pub fn get_ms() -> u64 { - abi_sys::get_ms() + userlib_sys::get_ms() } pub fn get_key() -> KeyEvent { - abi_sys::keyboard::get_key().into() + userlib_sys::keyboard::get_key().into() } pub mod display { use core::sync::atomic::{AtomicBool, Ordering}; - use abi_sys::CPixel; use embedded_graphics::{ - Pixel, geometry::{Dimensions, Point}, pixelcolor::Rgb565, prelude::{DrawTarget, Size}, primitives::Rectangle, + Pixel, }; + use userlib_sys::CPixel; pub const SCREEN_WIDTH: usize = 320; pub const SCREEN_HEIGHT: usize = 320; @@ -110,13 +110,13 @@ pub mod display { count += 1; if count == BUF_SIZE - 1 { - abi_sys::draw_iter(unsafe { BUF.as_ptr() }, count); + userlib_sys::draw_iter(unsafe { BUF.as_ptr() }, count); count = 0; } } if count > 0 { - abi_sys::draw_iter(unsafe { BUF.as_ptr() }, count); + userlib_sys::draw_iter(unsafe { BUF.as_ptr() }, count); } Ok(()) @@ -125,7 +125,7 @@ pub mod display { } fn gen_rand(req: &mut RngRequest) { - abi_sys::gen_rand(req); + userlib_sys::gen_rand(req); } pub struct Rng; @@ -162,7 +162,7 @@ pub mod fs { use core::fmt::Display; pub fn read_file(file: &str, start_from: usize, buf: &mut [u8]) -> usize { - abi_sys::read_file( + userlib_sys::read_file( file.as_ptr(), file.len(), start_from, @@ -172,7 +172,7 @@ pub mod fs { } pub fn write_file(file: &str, start_from: usize, buf: &[u8]) { - abi_sys::write_file( + userlib_sys::write_file( file.as_ptr(), file.len(), start_from, @@ -254,7 +254,7 @@ pub mod fs { } pub fn list_dir(path: &str, entries: &mut Entries) -> usize { - abi_sys::list_dir( + userlib_sys::list_dir( path.as_ptr(), path.len(), entries.as_ptrs().as_mut_ptr(), @@ -264,14 +264,14 @@ pub mod fs { } pub fn file_len(str: &str) -> usize { - abi_sys::file_len(str.as_ptr(), str.len()) + userlib_sys::file_len(str.as_ptr(), str.len()) } } pub mod audio { - pub use abi_sys::{AUDIO_BUFFER_LEN, AUDIO_BUFFER_SAMPLES, audio_buffer_ready}; + pub use userlib_sys::{audio_buffer_ready, AUDIO_BUFFER_LEN, AUDIO_BUFFER_SAMPLES}; pub fn send_audio_buffer(buf: &[u8]) { - abi_sys::send_audio_buffer(buf.as_ptr(), buf.len()) + userlib_sys::send_audio_buffer(buf.as_ptr(), buf.len()) } } diff --git a/abi_sys/Cargo.toml b/userlib_sys/Cargo.toml similarity index 94% rename from abi_sys/Cargo.toml rename to userlib_sys/Cargo.toml index 5a83d0b..c16eb9a 100644 --- a/abi_sys/Cargo.toml +++ b/userlib_sys/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "abi_sys" +name = "userlib_sys" version = "0.1.0" edition = "2024" diff --git a/abi_sys/src/lib.rs b/userlib_sys/src/lib.rs similarity index 100% rename from abi_sys/src/lib.rs rename to userlib_sys/src/lib.rs From 02877d03a653af9ca240580fec1ab8ada5bb1260 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Mon, 17 Nov 2025 18:27:32 -0700 Subject: [PATCH 10/19] clean --- kernel/src/main.rs | 2 +- userlib/src/lib.rs | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/kernel/src/main.rs b/kernel/src/main.rs index f32bfca..66570c7 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -39,7 +39,6 @@ use crate::{ storage::{SDCARD, SdCard}, ui::{SELECTIONS, clear_selection, ui_handler}, }; -use userlib_sys::EntryFn; use bumpalo::Bump; use core::sync::atomic::{AtomicBool, Ordering}; use embassy_executor::{Executor, Spawner}; @@ -73,6 +72,7 @@ use embedded_hal_bus::spi::ExclusiveDevice; use embedded_sdmmc::SdCard as SdmmcSdCard; use static_cell::StaticCell; use talc::*; +use userlib_sys::EntryFn; use {defmt_rtt as _, panic_probe as _}; embassy_rp::bind_interrupts!(struct Irqs { diff --git a/userlib/src/lib.rs b/userlib/src/lib.rs index 43aad4a..6c88cb2 100644 --- a/userlib/src/lib.rs +++ b/userlib/src/lib.rs @@ -6,8 +6,8 @@ extern crate alloc; pub use alloc::format; use core::alloc::{GlobalAlloc, Layout}; use rand_core::RngCore; +use userlib_sys::{RngRequest, keyboard::KeyEvent}; pub use userlib_sys::{keyboard, print}; -use userlib_sys::{keyboard::KeyEvent, RngRequest}; #[global_allocator] static ALLOC: Alloc = Alloc; @@ -48,11 +48,11 @@ pub mod display { use core::sync::atomic::{AtomicBool, Ordering}; use embedded_graphics::{ + Pixel, geometry::{Dimensions, Point}, pixelcolor::Rgb565, prelude::{DrawTarget, Size}, primitives::Rectangle, - Pixel, }; use userlib_sys::CPixel; @@ -269,7 +269,7 @@ pub mod fs { } pub mod audio { - pub use userlib_sys::{audio_buffer_ready, AUDIO_BUFFER_LEN, AUDIO_BUFFER_SAMPLES}; + pub use userlib_sys::{AUDIO_BUFFER_LEN, AUDIO_BUFFER_SAMPLES, audio_buffer_ready}; pub fn send_audio_buffer(buf: &[u8]) { userlib_sys::send_audio_buffer(buf.as_ptr(), buf.len()) From f015f67c872e2236e2fa2b549e523f0aeee3a318 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 18 Nov 2025 12:55:04 -0700 Subject: [PATCH 11/19] fix readme fix --- Cargo.lock | 8 ++++---- README.md | 8 ++++---- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a47adf1..a1a1a57 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -356,9 +356,9 @@ checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5" [[package]] name = "crypto-common" -version = "0.1.6" +version = "0.1.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" +checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a" dependencies = [ "generic-array", "typenum", @@ -1216,9 +1216,9 @@ dependencies = [ [[package]] name = "generic-array" -version = "0.14.9" +version = "0.14.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4bb6743198531e02858aeaea5398fcc883e71851fcbcb5a2f773e2fb6cb1edf2" +checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" dependencies = [ "typenum", "version_check", diff --git a/README.md b/README.md index 15b7c77..23247a9 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,17 @@ # PicoCalc OS (Rust) -A simple operating system for the **Clockwork PicoCalc**, written in Rust. +A simple kernel and applications for the **Clockwork PicoCalc**, written in Rust. This project provides a minimal kernel, ABI, and user-space applications to experiment with OS development on constrained hardware. ## Status Basic synchronous applications are working great. -Current focus is on exanding applications and porting software, finding bufs in ffi, and making sure the kernel is as stable as possible. +Current focus is on exanding applications and porting software, finding bugs in ffi, and making sure the kernel is as stable as possible. ## Project Structure -- **`kernel/`** – The core OS kernel (task scheduling, drivers, memory, etc.) -- **`userlib_sys/`** – FFI bindings for kernel syscalls - kernel ↔ userspace (Repr "C") +- **`kernel/`** – The core OS kernel +- **`userlib_sys/`** – C FFI bindings for kernel syscall - **`userlib/`** – Rust wrapper on top of `userlib_sys` - **`picolib/`** – Built with ```just newlib```, and provides libc symbols when linking with C libraries - **`user-apps/`** – Collection of userspace programs (gif player, wav player, calculator, snake, etc.) From 9035ebc757d1583d7bd6059eb4f2529a5210e51c Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 18 Nov 2025 13:18:36 -0700 Subject: [PATCH 12/19] fix heap deallocation --- kernel/src/heap.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/kernel/src/heap.rs b/kernel/src/heap.rs index 2b1de30..10b7710 100644 --- a/kernel/src/heap.rs +++ b/kernel/src/heap.rs @@ -22,7 +22,7 @@ impl Region { fn contains(&self, address: usize) -> bool { let start = self.start.load(Ordering::Relaxed); - let end = self.start.load(Ordering::Relaxed); + let end = start + self.size.load(Ordering::Relaxed); (start..start + end).contains(&address) } From 49c11978d51466ba43d201f740e5366f2ac7cc65 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 18 Nov 2025 13:37:50 -0700 Subject: [PATCH 13/19] rename syscall table from abi --- README.md | 2 +- justfile | 6 ++- kernel/src/elf.rs | 40 +++++++++---------- kernel/src/main.rs | 4 +- kernel/src/{abi.rs => syscalls.rs} | 22 +++++------ userlib_sys/src/lib.rs | 62 +++++++++++++++--------------- 6 files changed, 69 insertions(+), 67 deletions(-) rename kernel/src/{abi.rs => syscalls.rs} (95%) diff --git a/README.md b/README.md index 23247a9..9e1f265 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # PicoCalc OS (Rust) A simple kernel and applications for the **Clockwork PicoCalc**, written in Rust. -This project provides a minimal kernel, ABI, and user-space applications to experiment with OS development on constrained hardware. +This project provides a minimal kernel, syscall table, and user-space applications to experiment with kernel development on constrained hardware. ## Status diff --git a/justfile b/justfile index 913f0b5..aeb2060 100644 --- a/justfile +++ b/justfile @@ -1,10 +1,12 @@ +target := "thumbv8m.main-none-eabihf" + kernel-dev board: cargo run --bin kernel --features {{board}} --features fps kernel-release-probe board: cargo run --bin kernel --profile release --features {{board}} --features fps kernel-release board: cargo build --bin kernel --release --no-default-features --features {{board}} - elf2uf2-rs -d target/thumbv8m.main-none-eabihf/release/kernel + elf2uf2-rs -d target/{{target}}/release/kernel binary-args := "RUSTFLAGS=\"-C link-arg=-pie -C relocation-model=pic\"" @@ -42,7 +44,7 @@ userapps: cbindgen just userapp wav_player copy-userapp app: - cp ./target/thumbv8m.main-none-eabihf/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin + cp ./target/{{target}}/release-binary/{{app}} /run/media/$(whoami)/PICOCALC/{{app}}.bin copy-userapps: #!/bin/bash diff --git a/kernel/src/elf.rs b/kernel/src/elf.rs index 05aba55..2fbb7aa 100644 --- a/kernel/src/elf.rs +++ b/kernel/src/elf.rs @@ -1,8 +1,7 @@ use crate::{ - abi, storage::{File, SDCARD}, + syscalls, }; -use userlib_sys::{CallTable, EntryFn}; use alloc::{vec, vec::Vec}; use bumpalo::Bump; use core::ptr; @@ -17,6 +16,7 @@ use goblin::{ elf32::{header, reloc::Rel, section_header::SectionHeader, sym::Sym}, }; use strum::IntoEnumIterator; +use userlib_sys::{EntryFn, SyscallTable}; const ELF32_HDR_SIZE: usize = 52; @@ -70,7 +70,7 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> } } - patch_abi(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap(); + patch_syscalls(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap(); // entry pointer is base_ptr + (entry - min_vaddr) let entry_ptr: EntryFn = unsafe { @@ -150,7 +150,7 @@ fn apply_relocations( Ok(()) } -fn patch_abi( +fn patch_syscalls( elf_header: &Header, base: *mut u8, min_vaddr: u32, @@ -188,27 +188,27 @@ fn patch_abi( } let symbol_name = core::str::from_utf8(&name).unwrap(); - if symbol_name == "CALL_ABI_TABLE" { + if symbol_name == stringify!(SYS_CALL_TABLE) { let table_base = unsafe { base.add((sym.st_value as usize) - min_vaddr as usize) } as *mut usize; - for (idx, call) in CallTable::iter().enumerate() { + for (idx, call) in SyscallTable::iter().enumerate() { let ptr = match call { - CallTable::Alloc => abi::alloc as usize, - CallTable::Dealloc => abi::dealloc as usize, - CallTable::PrintString => abi::print as usize, - CallTable::SleepMs => abi::sleep as usize, - CallTable::GetMs => abi::get_ms as usize, - CallTable::DrawIter => abi::draw_iter as usize, - CallTable::GetKey => abi::get_key as usize, - CallTable::GenRand => abi::gen_rand as usize, - CallTable::ListDir => abi::list_dir as usize, - CallTable::ReadFile => abi::read_file as usize, - CallTable::WriteFile => abi::write_file as usize, - CallTable::FileLen => abi::file_len as usize, - CallTable::AudioBufferReady => abi::audio_buffer_ready as usize, - CallTable::SendAudioBuffer => abi::send_audio_buffer as usize, + SyscallTable::Alloc => syscalls::alloc as usize, + SyscallTable::Dealloc => syscalls::dealloc as usize, + SyscallTable::PrintString => syscalls::print as usize, + SyscallTable::SleepMs => syscalls::sleep as usize, + SyscallTable::GetMs => syscalls::get_ms as usize, + SyscallTable::DrawIter => syscalls::draw_iter as usize, + SyscallTable::GetKey => syscalls::get_key as usize, + SyscallTable::GenRand => syscalls::gen_rand as usize, + SyscallTable::ListDir => syscalls::list_dir as usize, + SyscallTable::ReadFile => syscalls::read_file as usize, + SyscallTable::WriteFile => syscalls::write_file as usize, + SyscallTable::FileLen => syscalls::file_len as usize, + SyscallTable::AudioBufferReady => syscalls::audio_buffer_ready as usize, + SyscallTable::SendAudioBuffer => syscalls::send_audio_buffer as usize, }; unsafe { table_base.add(idx as usize).write(ptr); diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 66570c7..81d7cc6 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -8,7 +8,6 @@ extern crate alloc; -mod abi; mod audio; mod display; mod elf; @@ -16,6 +15,7 @@ mod framebuffer; mod peripherals; mod scsi; mod storage; +mod syscalls; mod ui; mod usb; mod utils; @@ -31,12 +31,12 @@ mod psram; use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram, psram::init_psram_qmi}; use crate::{ - abi::{KEY_CACHE, MS_SINCE_LAUNCH}, audio::audio_handler, display::{FRAMEBUFFER, display_handler, init_display}, peripherals::{conf_peripherals, keyboard::read_keyboard_fifo}, scsi::MSC_SHUTDOWN, storage::{SDCARD, SdCard}, + syscalls::{KEY_CACHE, MS_SINCE_LAUNCH}, ui::{SELECTIONS, clear_selection, ui_handler}, }; use bumpalo::Bump; diff --git a/kernel/src/abi.rs b/kernel/src/syscalls.rs similarity index 95% rename from kernel/src/abi.rs rename to kernel/src/syscalls.rs index b5eec81..09b1840 100644 --- a/kernel/src/abi.rs +++ b/kernel/src/syscalls.rs @@ -1,14 +1,14 @@ use alloc::{string::ToString, vec::Vec}; use core::{ffi::c_char, ptr, sync::atomic::Ordering}; -use embassy_rp::clocks::{clk_sys_freq, RoscRng}; +use embassy_rp::clocks::{RoscRng, clk_sys_freq}; use embassy_time::Instant; use embedded_graphics::draw_target::DrawTarget; use embedded_sdmmc::LfnBuffer; use heapless::spsc::Queue; use userlib_sys::{ - keyboard::*, AllocAbi, AudioBufferReady, CLayout, CPixel, DeallocAbi, DrawIterAbi, FileLen, - GenRand, GetMsAbi, ListDir, PrintAbi, ReadFile, RngRequest, SendAudioBuffer, SleepMsAbi, - WriteFile, AUDIO_BUFFER_SAMPLES, + AUDIO_BUFFER_SAMPLES, Alloc, AudioBufferReady, CLayout, CPixel, Dealloc, DrawIter, FileLen, + GenRand, GetMs, ListDir, Print, ReadFile, RngRequest, SendAudioBuffer, SleepMs, WriteFile, + keyboard::*, }; #[cfg(feature = "psram")] @@ -24,7 +24,7 @@ use crate::{ storage::{Dir, File, SDCARD}, }; -const _: AllocAbi = alloc; +const _: Alloc = alloc; pub extern "C" fn alloc(layout: CLayout) -> *mut u8 { // SAFETY: caller guarantees layout is valid unsafe { @@ -40,7 +40,7 @@ pub extern "C" fn alloc(layout: CLayout) -> *mut u8 { } } -const _: DeallocAbi = dealloc; +const _: Dealloc = dealloc; pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) { // SAFETY: caller guarantees ptr and layout are valid #[cfg(feature = "psram")] @@ -54,7 +54,7 @@ pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) { } } -const _: PrintAbi = print; +const _: Print = print; pub extern "C" fn print(ptr: *const u8, len: usize) { // SAFETY: caller guarantees `ptr` is valid for `len` bytes let slice = unsafe { core::slice::from_raw_parts(ptr, len) }; @@ -68,7 +68,7 @@ pub extern "C" fn print(ptr: *const u8, len: usize) { } } -const _: SleepMsAbi = sleep; +const _: SleepMs = sleep; pub extern "C" fn sleep(ms: u64) { let cycles_per_ms = clk_sys_freq() / 1000; let total_cycles = ms * cycles_per_ms as u64; @@ -80,14 +80,14 @@ pub extern "C" fn sleep(ms: u64) { pub static mut MS_SINCE_LAUNCH: Option = None; -const _: GetMsAbi = get_ms; +const _: GetMs = get_ms; pub extern "C" fn get_ms() -> u64 { Instant::now() .duration_since(unsafe { MS_SINCE_LAUNCH.unwrap() }) .as_millis() } -const _: DrawIterAbi = draw_iter; +const _: DrawIter = draw_iter; pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) { // SAFETY: caller guarantees `ptr` is valid for `len` bytes let cpixels = unsafe { core::slice::from_raw_parts(cpixels, len) }; @@ -101,7 +101,7 @@ pub extern "C" fn draw_iter(cpixels: *const CPixel, len: usize) { pub static mut KEY_CACHE: Queue = Queue::new(); -const _: GetKeyAbi = get_key; +const _: GetKey = get_key; pub extern "C" fn get_key() -> KeyEventC { if let Some(event) = unsafe { KEY_CACHE.dequeue() } { event.into() diff --git a/userlib_sys/src/lib.rs b/userlib_sys/src/lib.rs index 0b26e9f..1e275b3 100644 --- a/userlib_sys/src/lib.rs +++ b/userlib_sys/src/lib.rs @@ -12,12 +12,12 @@ use strum::{EnumCount, EnumIter}; pub type EntryFn = fn(); -pub const ABI_CALL_TABLE_COUNT: usize = 14; -const _: () = assert!(ABI_CALL_TABLE_COUNT == CallTable::COUNT); +pub const SYS_CALL_TABLE_COUNT: usize = 14; +const _: () = assert!(SYS_CALL_TABLE_COUNT == SyscallTable::COUNT); #[derive(Clone, Copy, EnumIter, EnumCount)] #[repr(u8)] -pub enum CallTable { +pub enum SyscallTable { Alloc = 0, Dealloc = 1, PrintString = 2, @@ -36,7 +36,7 @@ pub enum CallTable { #[unsafe(no_mangle)] #[unsafe(link_section = ".syscall_table")] -pub static mut CALL_ABI_TABLE: [usize; ABI_CALL_TABLE_COUNT] = [0; ABI_CALL_TABLE_COUNT]; +pub static mut SYS_CALL_TABLE: [usize; SYS_CALL_TABLE_COUNT] = [0; SYS_CALL_TABLE_COUNT]; #[cfg(feature = "alloc")] #[repr(C)] @@ -62,46 +62,46 @@ impl From for CLayout { } } -pub type AllocAbi = extern "C" fn(layout: CLayout) -> *mut u8; +pub type Alloc = extern "C" fn(layout: CLayout) -> *mut u8; #[unsafe(no_mangle)] pub extern "C" fn alloc(layout: CLayout) -> *mut u8 { - let f: AllocAbi = unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::Alloc as usize]) }; + let f: Alloc = unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::Alloc as usize]) }; f(layout) } -pub type DeallocAbi = extern "C" fn(ptr: *mut u8, layout: CLayout); +pub type Dealloc = extern "C" fn(ptr: *mut u8, layout: CLayout); #[unsafe(no_mangle)] pub extern "C" fn dealloc(ptr: *mut u8, layout: CLayout) { - let f: DeallocAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::Dealloc as usize]) }; + let f: Dealloc = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::Dealloc as usize]) }; f(ptr, layout) } -pub type PrintAbi = extern "C" fn(ptr: *const u8, len: usize); +pub type Print = extern "C" fn(ptr: *const u8, len: usize); #[unsafe(no_mangle)] pub extern "C" fn print(ptr: *const u8, len: usize) { - let f: PrintAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::PrintString as usize]) }; + let f: Print = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::PrintString as usize]) }; f(ptr, len); } -pub type SleepMsAbi = extern "C" fn(ms: u64); +pub type SleepMs = extern "C" fn(ms: u64); #[unsafe(no_mangle)] pub extern "C" fn sleep(ms: u64) { - let f: SleepMsAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::SleepMs as usize]) }; + let f: SleepMs = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::SleepMs as usize]) }; f(ms); } -pub type GetMsAbi = extern "C" fn() -> u64; +pub type GetMs = extern "C" fn() -> u64; #[unsafe(no_mangle)] pub extern "C" fn get_ms() -> u64 { - let f: GetMsAbi = unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::GetMs as usize]) }; + let f: GetMs = unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::GetMs as usize]) }; f() } @@ -139,17 +139,17 @@ impl Into> for CPixel { } } -pub type DrawIterAbi = extern "C" fn(ptr: *const CPixel, len: usize); +pub type DrawIter = extern "C" fn(ptr: *const CPixel, len: usize); #[unsafe(no_mangle)] pub extern "C" fn draw_iter(ptr: *const CPixel, len: usize) { - let f: DrawIterAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::DrawIter as usize]) }; + let f: DrawIter = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::DrawIter as usize]) }; f(ptr, len); } pub mod keyboard { - use crate::{CALL_ABI_TABLE, CallTable}; + use crate::{SYS_CALL_TABLE, SyscallTable}; bitflags::bitflags! { #[derive(Default, Debug, PartialEq, Eq, Clone, Copy)] @@ -367,12 +367,12 @@ pub mod keyboard { } } - pub type GetKeyAbi = extern "C" fn() -> KeyEventC; + pub type GetKey = extern "C" fn() -> KeyEventC; #[unsafe(no_mangle)] pub extern "C" fn get_key() -> KeyEventC { - let f: GetKeyAbi = - unsafe { core::mem::transmute(CALL_ABI_TABLE[CallTable::GetKey as usize]) }; + let f: GetKey = + unsafe { core::mem::transmute(SYS_CALL_TABLE[SyscallTable::GetKey as usize]) }; f() } } @@ -389,7 +389,7 @@ pub type GenRand = extern "C" fn(req: &mut RngRequest); #[unsafe(no_mangle)] pub extern "C" fn gen_rand(req: &mut RngRequest) { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::GenRand as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::GenRand as usize]; let f: GenRand = core::mem::transmute(ptr); f(req) } @@ -412,7 +412,7 @@ pub extern "C" fn list_dir( max_entry_str_len: usize, ) -> usize { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::ListDir as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::ListDir as usize]; let f: ListDir = core::mem::transmute(ptr); f(str, len, entries, entry_count, max_entry_str_len) } @@ -435,7 +435,7 @@ pub extern "C" fn read_file( buf_len: usize, ) -> usize { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::ReadFile as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::ReadFile as usize]; let f: ReadFile = core::mem::transmute(ptr); f(str, len, read_from, buf, buf_len) } @@ -453,7 +453,7 @@ pub extern "C" fn write_file( buf_len: usize, ) { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::WriteFile as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::WriteFile as usize]; let f: WriteFile = core::mem::transmute(ptr); f(str, len, write_from, buf, buf_len) } @@ -464,7 +464,7 @@ pub type FileLen = extern "C" fn(str: *const u8, len: usize) -> usize; #[unsafe(no_mangle)] pub extern "C" fn file_len(str: *const u8, len: usize) -> usize { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::FileLen as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::FileLen as usize]; let f: FileLen = core::mem::transmute(ptr); f(str, len) } @@ -475,7 +475,7 @@ pub type AudioBufferReady = extern "C" fn() -> bool; #[allow(unused)] pub fn audio_buffer_ready() -> bool { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::AudioBufferReady as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::AudioBufferReady as usize]; let f: AudioBufferReady = core::mem::transmute(ptr); f() } @@ -489,7 +489,7 @@ pub type SendAudioBuffer = extern "C" fn(ptr: *const u8, len: usize); #[allow(unused)] pub fn send_audio_buffer(buf: *const u8, len: usize) { unsafe { - let ptr = CALL_ABI_TABLE[CallTable::SendAudioBuffer as usize]; + let ptr = SYS_CALL_TABLE[SyscallTable::SendAudioBuffer as usize]; let f: SendAudioBuffer = core::mem::transmute(ptr); f(buf, len) } From cc31cb4711472a1f979c7f9cb83a57113c1c7280 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 18 Nov 2025 15:20:03 -0700 Subject: [PATCH 14/19] clippy --- kernel/Cargo.toml | 2 +- kernel/build.rs | 2 +- kernel/src/audio.rs | 6 ++- kernel/src/display.rs | 14 ++++--- kernel/src/elf.rs | 23 +++++------ kernel/src/framebuffer.rs | 12 +++--- kernel/src/main.rs | 12 ++++-- kernel/src/psram.rs | 2 +- kernel/src/scsi/mod.rs | 69 +++++++++++++++----------------- kernel/src/scsi/scsi_types.rs | 3 +- kernel/src/storage.rs | 23 ++--------- kernel/src/syscalls.rs | 24 ++++++----- kernel/src/ui.rs | 50 +++++++++++------------ selection_ui/src/lib.rs | 17 ++++---- user_apps/calculator/src/main.rs | 2 +- user_apps/gallery/src/main.rs | 15 +++---- user_apps/gif/src/main.rs | 19 ++++----- user_apps/wav_player/src/main.rs | 21 +++++----- userlib/src/lib.rs | 6 +++ userlib_sys/src/lib.rs | 57 +++++++++++++------------- 20 files changed, 182 insertions(+), 197 deletions(-) diff --git a/kernel/Cargo.toml b/kernel/Cargo.toml index 58f380c..5c03af9 100644 --- a/kernel/Cargo.toml +++ b/kernel/Cargo.toml @@ -11,7 +11,7 @@ doctest = false bench = false [features] -default = ["rp235x", "defmt"] +default = ["rp235x"] pimoroni2w = ["rp235x", "psram"] # rp2040 = ["embassy-rp/rp2040"] # unsupported, ram too small for fb rp235x = ["embassy-rp/rp235xb"] diff --git a/kernel/build.rs b/kernel/build.rs index 8220df0..a3a1b63 100644 --- a/kernel/build.rs +++ b/kernel/build.rs @@ -14,7 +14,7 @@ use std::io::Write; use std::path::PathBuf; #[cfg(all(feature = "rp235x", not(feature = "pimoroni2w")))] -const MEMORY: &'static [u8] = include_bytes!("rp2350.x"); +const MEMORY: &[u8] = include_bytes!("rp2350.x"); #[cfg(feature = "pimoroni2w")] const MEMORY: &'static [u8] = include_bytes!("rp2350.x"); diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index e26c939..cfcad55 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -120,8 +120,10 @@ impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> { let mut cfg = Config::default(); cfg.set_set_pins(&[&pin]); cfg.fifo_join = FifoJoin::TxOnly; - let mut shift_cfg = ShiftConfig::default(); - shift_cfg.auto_fill = true; + let shift_cfg = ShiftConfig { + auto_fill: true, + ..Default::default() + }; cfg.shift_out = shift_cfg; cfg.use_program(&prg.0, &[]); sm.set_config(&cfg); diff --git a/kernel/src/display.rs b/kernel/src/display.rs index 568e441..cca521b 100644 --- a/kernel/src/display.rs +++ b/kernel/src/display.rs @@ -1,5 +1,4 @@ use crate::framebuffer::{self, AtomicFrameBuffer, FB_PAUSED}; -use core::alloc::{GlobalAlloc, Layout}; use core::sync::atomic::Ordering; use embassy_futures::yield_now; use embassy_rp::{ @@ -9,17 +8,20 @@ use embassy_rp::{ spi::{Async, Spi}, }; use embassy_time::Delay; -use embedded_graphics::{draw_target::DrawTarget, pixelcolor::Rgb565, prelude::RgbColor}; use embedded_hal_bus::spi::ExclusiveDevice; use st7365p_lcd::ST7365P; #[cfg(feature = "psram")] use crate::heap::HEAP; +#[cfg(feature = "psram")] +use core::alloc::{GlobalAlloc, Layout}; +#[cfg(feature = "psram")] +use embedded_graphics::{draw_target::DrawTarget, pixelcolor::Rgb565, prelude::RgbColor}; #[cfg(feature = "fps")] pub use framebuffer::fps::{FPS_CANVAS, FPS_COUNTER}; -type DISPLAY = ST7365P< +type Display = ST7365P< ExclusiveDevice, Output<'static>, Delay>, Output<'static>, Output<'static>, @@ -56,7 +58,7 @@ pub async fn init_display( cs: Peri<'static, PIN_13>, data: Peri<'static, PIN_14>, reset: Peri<'static, PIN_15>, -) -> DISPLAY { +) -> Display { init_fb(); let spi_device = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap(); @@ -84,7 +86,7 @@ pub async fn init_display( } #[embassy_executor::task] -pub async fn display_handler(mut display: DISPLAY) { +pub async fn display_handler(mut display: Display) { use embassy_time::{Instant, Timer}; // Target ~60 Hz refresh (≈16.67 ms per frame) @@ -111,7 +113,7 @@ pub async fn display_handler(mut display: DISPLAY) { } } - let elapsed = start.elapsed().as_millis() as u64; + let elapsed = start.elapsed().as_millis(); if elapsed < FRAME_TIME_MS { Timer::after_millis(FRAME_TIME_MS - elapsed).await; } else { diff --git a/kernel/src/elf.rs b/kernel/src/elf.rs index 2fbb7aa..0ab37d2 100644 --- a/kernel/src/elf.rs +++ b/kernel/src/elf.rs @@ -39,7 +39,7 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> let mut ph_buf = vec![0_u8; elf_header.e_phentsize as usize]; let (total_size, min_vaddr, _max_vaddr) = - total_loadable_size(&mut file, &elf_header, &mut ph_buf); + total_loadable_size(&mut file, elf_header, &mut ph_buf); let bump = Bump::with_capacity(total_size); let base = bump.alloc_slice_fill_default::(total_size); @@ -52,25 +52,22 @@ pub async unsafe fn load_binary(name: &ShortFileName) -> Option<(EntryFn, Bump)> let ph = cast_phdr(&ph_buf); let seg_offset = (ph.p_vaddr - min_vaddr) as usize; - let mut segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize]; + let segment = &mut base[seg_offset..seg_offset + ph.p_memsz as usize]; if ph.p_type == PT_LOAD { - load_segment(&mut file, &ph, &mut segment).unwrap(); + load_segment(&mut file, &ph, segment).unwrap(); } } for i in 0..elf_header.e_shnum { let sh = read_section(&mut file, elf_header, i.into()); - match sh.sh_type { - SHT_REL => { - apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap(); - } - _ => {} + if sh.sh_type == SHT_REL { + apply_relocations(&sh, min_vaddr, base.as_mut_ptr(), &mut file).unwrap(); } } - patch_syscalls(&elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap(); + patch_syscalls(elf_header, base.as_mut_ptr(), min_vaddr, &mut file).unwrap(); // entry pointer is base_ptr + (entry - min_vaddr) let entry_ptr: EntryFn = unsafe { @@ -157,7 +154,7 @@ fn patch_syscalls( file: &mut File, ) -> Result<(), ()> { for i in 1..=elf_header.e_shnum { - let sh = read_section(file, &elf_header, i.into()); + let sh = read_section(file, elf_header, i.into()); // find the symbol table if sh.sh_type == SHT_SYMTAB { @@ -172,7 +169,7 @@ fn patch_syscalls( &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 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) @@ -211,7 +208,7 @@ fn patch_syscalls( SyscallTable::SendAudioBuffer => syscalls::send_audio_buffer as usize, }; unsafe { - table_base.add(idx as usize).write(ptr); + table_base.add(idx).write(ptr); } } return Ok(()); @@ -233,7 +230,7 @@ fn total_loadable_size( file.seek_from_start(elf_header.e_phoff + (elf_header.e_phentsize * i) as u32) .unwrap(); file.read(ph_buf).unwrap(); - let ph = cast_phdr(&ph_buf); + let ph = cast_phdr(ph_buf); if ph.p_type == PT_LOAD { if ph.p_vaddr < min_vaddr { diff --git a/kernel/src/framebuffer.rs b/kernel/src/framebuffer.rs index 994b4b4..7df00b1 100644 --- a/kernel/src/framebuffer.rs +++ b/kernel/src/framebuffer.rs @@ -46,7 +46,7 @@ impl<'a> AtomicFrameBuffer<'a> { } fn mark_tiles_dirty(&mut self, rect: Rectangle) { - let tiles_x = (SCREEN_WIDTH + TILE_SIZE - 1) / TILE_SIZE; + let tiles_x = SCREEN_WIDTH.div_ceil(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; @@ -346,11 +346,10 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> { } } - if changed { - if let Some(rect) = dirty_rect { + if changed + && let Some(rect) = dirty_rect { self.mark_tiles_dirty(rect); } - } Ok(()) } @@ -402,7 +401,7 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> { 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), + core::iter::repeat_n(color, (self.size().width * self.size().height) as usize), ) } @@ -412,8 +411,7 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> { 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), + core::iter::repeat_n(RawU16::from(color).into_inner(), (self.size().width * self.size().height) as usize), )?; for tile in self.dirty_tiles.iter() { diff --git a/kernel/src/main.rs b/kernel/src/main.rs index 81d7cc6..fa08eda 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -12,11 +12,15 @@ mod audio; mod display; mod elf; mod framebuffer; +// TODO: NEED TO UPDATE MCU TO TEST BATTERY READS +#[allow(unused)] mod peripherals; +#[allow(unused)] mod scsi; mod storage; mod syscalls; mod ui; +#[allow(unused)] mod usb; mod utils; @@ -28,7 +32,7 @@ mod heap; mod psram; #[cfg(feature = "psram")] -use crate::{heap::HEAP, heap::init_qmi_psram_heap, psram::init_psram, psram::init_psram_qmi}; +use crate::{heap::init_qmi_psram_heap, psram::init_psram_qmi}; use crate::{ audio::audio_handler, @@ -102,7 +106,7 @@ async fn watchdog_task(mut watchdog: Watchdog) { ResetReason::Forced => "forced", ResetReason::TimedOut => "timed out", }; - #[cfg(feature = "debug")] + #[cfg(feature = "defmt")] defmt::error!("Watchdog reset reason: {}", _reason); } @@ -321,7 +325,7 @@ async fn setup_display(display: Display, spawner: Spawner) { async fn setup_qmi_psram() { Timer::after_millis(250).await; let psram_qmi_size = init_psram_qmi(&embassy_rp::pac::QMI, &embassy_rp::pac::XIP_CTRL); - #[cfg(feature = "debug")] + #[cfg(feature = "defmt")] defmt::info!("size: {}", psram_qmi_size); Timer::after_millis(100).await; @@ -363,7 +367,7 @@ async fn kernel_task( .spawn(watchdog_task(Watchdog::new(watchdog))) .unwrap(); - #[cfg(feature = "debug")] + #[cfg(feature = "defmt")] defmt::info!("Clock: {}", embassy_rp::clocks::clk_sys_freq()); setup_mcu(mcu).await; diff --git a/kernel/src/psram.rs b/kernel/src/psram.rs index 91d447a..4a0d3ec 100644 --- a/kernel/src/psram.rs +++ b/kernel/src/psram.rs @@ -526,7 +526,7 @@ pub fn init_psram_qmi( let psram_size = detect_psram_qmi(qmi); if psram_size == 0 { - #[cfg(feature = "debug")] + #[cfg(feature = "defmt")] defmt::error!("qmi psram size 0"); return 0; } diff --git a/kernel/src/scsi/mod.rs b/kernel/src/scsi/mod.rs index 9618563..faf3ec9 100644 --- a/kernel/src/scsi/mod.rs +++ b/kernel/src/scsi/mod.rs @@ -30,7 +30,7 @@ pub struct MassStorageClass<'d, D: Driver<'d>> { bulk_in: D::EndpointIn, } -impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { +impl<'d, D: Driver<'d>> MassStorageClass<'d, D> { pub fn new(builder: &mut Builder<'d, D>, temp_sd: Option) -> Self { let mut function = builder.function(0x08, SUBCLASS_SCSI, 0x50); // Mass Storage class let mut interface = function.interface(); @@ -72,35 +72,34 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { async fn handle_cbw(&mut self) { 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]) { - // Take sdcard to increase speed - if self.temp_sd.is_none() { - let mut guard = SDCARD.get().lock().await; - if let Some(sd) = guard.take() { - self.temp_sd = Some(sd); - } else { - #[cfg(feature = "defmt")] - defmt::warn!("Tried to take SDCARD but it was already taken"); - return; - } - } - - let command = parse_cb(&cbw.CBWCB); - if self.handle_command(command).await.is_ok() { - self.send_csw_success(cbw.dCBWTag).await - } else { - self.send_csw_fail(cbw.dCBWTag).await - } - - if self.pending_eject { - if let ScsiCommand::Write { lba: _, len: _ } = command { - MSC_SHUTDOWN.signal(()); - } - } + if let Ok(n) = self.bulk_out.read(&mut cbw_buf).await + && n == 31 + && let Some(cbw) = CommandBlockWrapper::parse(&cbw_buf[..n]) + { + // Take sdcard to increase speed + if self.temp_sd.is_none() { + let mut guard = SDCARD.get().lock().await; + if let Some(sd) = guard.take() { + self.temp_sd = Some(sd); + } else { + #[cfg(feature = "defmt")] + defmt::warn!("Tried to take SDCARD but it was already taken"); + return; } } + + let command = parse_cb(&cbw.CBWCB); + if self.handle_command(command).await.is_ok() { + self.send_csw_success(cbw.dCBWTag).await + } else { + self.send_csw_fail(cbw.dCBWTag).await + } + + if self.pending_eject + && let ScsiCommand::Write { lba: _, len: _ } = command + { + MSC_SHUTDOWN.signal(()); + } } } @@ -238,7 +237,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { let block_size = SdCard::BLOCK_SIZE as u64; let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size; - let last_lba = total_blocks.checked_sub(1).unwrap_or(0); + let last_lba = total_blocks.saturating_sub(1); response.extend_from_slice(&(last_lba as u32).to_be_bytes())?; response.extend_from_slice(&(block_size as u32).to_be_bytes())?; @@ -249,7 +248,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { let block_size = SdCard::BLOCK_SIZE as u64; let total_blocks = self.temp_sd.as_ref().unwrap().size() / block_size; - let last_lba = total_blocks.checked_sub(1).unwrap_or(0); + let last_lba = total_blocks.saturating_sub(1); 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 @@ -269,7 +268,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { sdcard.read_blocks(block_buf, BlockIdx(idx as u32))?; for block in &mut *block_buf { - for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) { + for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE) { self.bulk_in.write(chunk).await.map_err(|_| ())?; } } @@ -281,7 +280,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { .read_blocks(&mut block_buf[..blocks as usize], BlockIdx(idx as u32))?; for block in &block_buf[..blocks as usize] { - for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE.into()) { + for chunk in block.contents.chunks(BULK_ENDPOINT_PACKET_SIZE) { self.bulk_in.write(chunk).await.map_err(|_| ())?; } } @@ -301,8 +300,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { while blocks > 0 { if blocks >= block_buf.len() as u64 { for block in block_buf.as_mut() { - for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into()) - { + for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE) { self.bulk_out.read(chunk).await.map_err(|_| ())?; } } @@ -313,8 +311,7 @@ impl<'d, 's, D: Driver<'d>> MassStorageClass<'d, D> { idx += block_buf.len() as u64; } else { for block in block_buf[..blocks as usize].as_mut() { - for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE.into()) - { + for chunk in block.contents.chunks_mut(BULK_ENDPOINT_PACKET_SIZE) { self.bulk_out.read(chunk).await.map_err(|_| ())?; } } diff --git a/kernel/src/scsi/scsi_types.rs b/kernel/src/scsi/scsi_types.rs index 76bbb8a..2d64d80 100644 --- a/kernel/src/scsi/scsi_types.rs +++ b/kernel/src/scsi/scsi_types.rs @@ -1,7 +1,7 @@ use num_enum::TryFromPrimitive; /// 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 @@ -91,6 +91,7 @@ pub enum ScsiCommand { }, } +#[allow(clippy::enum_variant_names)] #[repr(u8)] #[derive(Copy, Clone, Debug, TryFromPrimitive)] #[cfg_attr(feature = "defmt", derive(defmt::Format))] diff --git a/kernel/src/storage.rs b/kernel/src/storage.rs index 0632fa5..c77974b 100644 --- a/kernel/src/storage.rs +++ b/kernel/src/storage.rs @@ -9,8 +9,8 @@ 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, + Block, BlockDevice, BlockIdx, Directory, SdCard as SdmmcSdCard, TimeSource, Timestamp, + VolumeIdx, VolumeManager, sdcard::Error, }; use embedded_sdmmc::{File as SdFile, LfnBuffer, Mode, ShortFileName}; @@ -21,7 +21,6 @@ pub const MAX_VOLUMES: usize = 1; type Device = ExclusiveDevice, Output<'static>, embassy_time::Delay>; type SD = SdmmcSdCard; type VolMgr = VolumeManager; -type Vol<'a> = Volume<'a, SD, DummyTimeSource, MAX_DIRS, MAX_FILES, MAX_VOLUMES>; pub 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>; @@ -43,7 +42,7 @@ pub struct FileName { impl PartialOrd for FileName { fn partial_cmp(&self, other: &Self) -> Option { - Some(self.long_name.cmp(&other.long_name)) + Some(self.cmp(other)) } } @@ -67,10 +66,7 @@ impl SdCard { DummyTimeSource {}, 5000, ); - Self { - det: det, - volume_mgr, - } + Self { det, volume_mgr } } /// Returns true if an SD card is inserted. @@ -90,17 +86,6 @@ impl SdCard { 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| { diff --git a/kernel/src/syscalls.rs b/kernel/src/syscalls.rs index 09b1840..ca3daf2 100644 --- a/kernel/src/syscalls.rs +++ b/kernel/src/syscalls.rs @@ -35,7 +35,7 @@ pub extern "C" fn alloc(layout: CLayout) -> *mut u8 { #[cfg(not(feature = "psram"))] { - return alloc::alloc::alloc(layout.into()); + alloc::alloc::alloc(layout.into()) } } } @@ -134,7 +134,7 @@ unsafe fn copy_entry_to_user_buf(name: &[u8], dest: *mut c_char, max_str_len: us if !dest.is_null() { let len = name.len().min(max_str_len - 1); unsafe { - ptr::copy_nonoverlapping(name.as_ptr(), dest as *mut u8, len); + ptr::copy_nonoverlapping(name.as_ptr(), dest, len); *dest.add(len) = 0; // nul terminator } } @@ -191,7 +191,7 @@ pub extern "C" fn list_dir( let mut wrote = 0; sd.access_root_dir(|root| { - if dirs[0] == "" && dirs.len() >= 2 { + if dirs[0].is_empty() && dirs.len() >= 2 { unsafe { if dir == "/" { wrote = get_dir_entries(&root, files, max_entry_str_len); @@ -214,10 +214,10 @@ fn recurse_file( let mut buf = LfnBuffer::new(&mut b); let mut short_name = None; dir.iterate_dir_lfn(&mut buf, |entry, name| { - if let Some(name) = name { - if name == dirs[0] || entry.name.to_string().as_str() == dirs[0] { - short_name = Some(entry.name.clone()); - } + if let Some(name) = name + && (name == dirs[0] || entry.name.to_string().as_str() == dirs[0]) + { + short_name = Some(entry.name.clone()); } }) .expect("Failed to iterate dir"); @@ -257,7 +257,7 @@ pub extern "C" fn read_file( } // SAFETY: caller guarantees `ptr` is valid for `len` bytes - let mut buf = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) }; + let buf = unsafe { core::slice::from_raw_parts_mut(buf, buf_len) }; let mut read = 0; @@ -267,7 +267,7 @@ pub extern "C" fn read_file( sd.access_root_dir(|root| { if let Ok(result) = recurse_file(&root, &components[1..count], |file| { file.seek_from_start(start_from as u32).unwrap_or(()); - file.read(&mut buf).unwrap() + file.read(buf).unwrap() }) { read = result }; @@ -306,7 +306,7 @@ pub extern "C" fn write_file( sd.access_root_dir(|root| { recurse_file(&root, &components[1..count], |file| { file.seek_from_start(start_from as u32).unwrap(); - file.write(&buf).unwrap() + file.write(buf).unwrap() }) .unwrap_or(()) }); @@ -343,7 +343,9 @@ pub extern "C" fn send_audio_buffer(ptr: *const u8, len: usize) { // SAFETY: caller guarantees `ptr` is valid for `len` bytes let buf = unsafe { core::slice::from_raw_parts(ptr, len) }; - while !AUDIO_BUFFER_READY.load(Ordering::Acquire) {} + while !AUDIO_BUFFER_READY.load(Ordering::Acquire) { + core::hint::spin_loop(); + } if buf.len() == AUDIO_BUFFER_SAMPLES * 2 { AUDIO_BUFFER_READY.store(false, Ordering::Release); diff --git a/kernel/src/ui.rs b/kernel/src/ui.rs index 6416276..675ad86 100644 --- a/kernel/src/ui.rs +++ b/kernel/src/ui.rs @@ -2,7 +2,6 @@ use crate::{ BINARY_CH, display::FRAMEBUFFER, elf::load_binary, framebuffer::FB_PAUSED, peripherals::keyboard, storage::FileName, }; -use userlib_sys::keyboard::{KeyCode, KeyState}; use alloc::{str::FromStr, string::String, vec::Vec}; use core::sync::atomic::Ordering; use embassy_sync::{blocking_mutex::raw::CriticalSectionRawMutex, mutex::Mutex}; @@ -20,37 +19,38 @@ use embedded_layout::{ prelude::*, }; use embedded_text::TextBox; +use userlib_sys::keyboard::{KeyCode, KeyState}; pub static SELECTIONS: Mutex = Mutex::new(SelectionList::new()); pub async fn ui_handler() { loop { - if let Some(event) = keyboard::read_keyboard_fifo().await { - if let KeyState::Pressed = event.state { - match event.key { - KeyCode::Up => { - let mut selections = SELECTIONS.lock().await; - selections.up(); - } - KeyCode::Down => { - let mut selections = SELECTIONS.lock().await; - selections.down(); - } - KeyCode::Enter | KeyCode::Right => { - let selections = SELECTIONS.lock().await; - let selection = - selections.selections[selections.current_selection as usize].clone(); - - let entry = unsafe { - load_binary(&selection.short_name) - .await - .expect("unable to load binary") - }; - BINARY_CH.send(entry).await; - } - _ => (), + if let Some(event) = keyboard::read_keyboard_fifo().await + && let KeyState::Pressed = event.state + { + match event.key { + KeyCode::Up => { + let mut selections = SELECTIONS.lock().await; + selections.up(); } + KeyCode::Down => { + let mut selections = SELECTIONS.lock().await; + selections.down(); + } + KeyCode::Enter | KeyCode::Right => { + let selections = SELECTIONS.lock().await; + let selection = + selections.selections[selections.current_selection as usize].clone(); + + let entry = unsafe { + load_binary(&selection.short_name) + .await + .expect("unable to load binary") + }; + BINARY_CH.send(entry).await; + } + _ => (), } } diff --git a/selection_ui/src/lib.rs b/selection_ui/src/lib.rs index 9844fce..f0639c5 100644 --- a/selection_ui/src/lib.rs +++ b/selection_ui/src/lib.rs @@ -51,15 +51,14 @@ impl<'a> SelectionUi<'a> { let selection; loop { let key = get_key(); - if key.state == KeyState::Pressed { - if let Some(s) = self.update(display, key.key)? { + if key.state == KeyState::Pressed + && let Some(s) = self.update(display, key.key)? { selection = Some(s); display .clear(Rgb565::BLACK) - .map_err(|e| SelectionUiError::DisplayError(e))?; + .map_err(SelectionUiError::DisplayError)?; break; } - } } Ok(selection) } @@ -100,7 +99,7 @@ impl<'a> SelectionUi<'a> { Rectangle::new(bounds.top_left, bounds.size) .into_styled(PrimitiveStyle::with_fill(Rgb565::BLACK)) .draw(display) - .map_err(|e| SelectionUiError::DisplayError(e))?; + .map_err(SelectionUiError::DisplayError)?; } let mut views: Vec>> = Vec::new(); @@ -119,7 +118,7 @@ impl<'a> SelectionUi<'a> { layout .draw(display) - .map_err(|e| SelectionUiError::DisplayError(e))?; + .map_err(SelectionUiError::DisplayError)?; // draw selected box if let Some(selected_bounds) = layout.inner().get(self.selection) { @@ -127,7 +126,7 @@ impl<'a> SelectionUi<'a> { Rectangle::new(selected_bounds.top_left, selected_bounds.size) .into_styled(PrimitiveStyle::with_stroke(Rgb565::WHITE, 1)) .draw(display) - .map_err(|e| SelectionUiError::DisplayError(e))?; + .map_err(SelectionUiError::DisplayError)?; self.last_bounds = Some(selected_bounds); } @@ -136,9 +135,9 @@ impl<'a> SelectionUi<'a> { } } -pub fn draw_text_center<'a, S>( +pub fn draw_text_center( display: &mut Display, - text: &'a str, + text: &str, style: S, ) -> Result::Error> where diff --git a/user_apps/calculator/src/main.rs b/user_apps/calculator/src/main.rs index fe559c7..a758dc1 100644 --- a/user_apps/calculator/src/main.rs +++ b/user_apps/calculator/src/main.rs @@ -83,7 +83,7 @@ pub fn main() { .align_to(&display.bounding_box(), horizontal::Left, vertical::Center); let result = if let Ok(result) = evaluate(&input[input_min..]) { - &format!(" = {}", result) + &format!(" = {result}") } else { " = Error" }; diff --git a/user_apps/gallery/src/main.rs b/user_apps/gallery/src/main.rs index 35c9e34..0efeec4 100644 --- a/user_apps/gallery/src/main.rs +++ b/user_apps/gallery/src/main.rs @@ -51,9 +51,9 @@ pub fn main() { println!("file: {}", file); if file.extension().unwrap_or("") == "bmp" || file.extension().unwrap_or("") == "BMP" { - let file_path = format!("/images/{}", file); + let file_path = format!("/images/{file}"); - let read = read_file(&file_path, 0, &mut &mut bmp_buf[..]); + let read = read_file(&file_path, 0, &mut bmp_buf[..]); if read > 0 { let bmp = Bmp::from_slice(&bmp_buf).expect("failed to parse bmp"); @@ -74,7 +74,7 @@ pub fn main() { let text_style = MonoTextStyle::new(&FONT_6X10, Rgb565::WHITE); let text_y = y + bmp_h + 2; // 2px gap under image - Text::new(&file.base(), Point::new(cell_x + 2, text_y), text_style) + Text::new(file.base(), Point::new(cell_x + 2, text_y), text_style) .draw(&mut display) .unwrap(); @@ -85,11 +85,8 @@ pub fn main() { loop { let event = get_key(); - if event.state != KeyState::Idle { - match event.key { - KeyCode::Esc => return, - _ => (), - } - }; + if event.state != KeyState::Idle && event.key == KeyCode::Esc { + return; + } } } diff --git a/user_apps/gif/src/main.rs b/user_apps/gif/src/main.rs index 0e263b8..a912fb5 100644 --- a/user_apps/gif/src/main.rs +++ b/user_apps/gif/src/main.rs @@ -6,16 +6,16 @@ use alloc::{format, vec, vec::Vec}; use core::panic::PanicInfo; use embedded_graphics::{ image::ImageDrawable, - mono_font::{ascii::FONT_6X10, MonoTextStyle}, + mono_font::{MonoTextStyle, ascii::FONT_6X10}, pixelcolor::Rgb565, prelude::{Point, RgbColor}, transform::Transform, }; -use selection_ui::{draw_text_center, SelectionUi, SelectionUiError}; +use selection_ui::{SelectionUi, SelectionUiError, draw_text_center}; use tinygif::Gif; use userlib::{ display::{Display, SCREEN_HEIGHT, SCREEN_WIDTH}, - fs::{file_len, list_dir, read_file, Entries}, + fs::{Entries, file_len, list_dir, read_file}, get_key, get_ms, keyboard::{KeyCode, KeyState}, println, sleep, @@ -44,7 +44,7 @@ pub fn main() { let mut gifs = files.iter().map(|e| e.full_name()).collect::>(); gifs.sort(); - let mut selection_ui = SelectionUi::new(&mut gifs); + let mut selection_ui = SelectionUi::new(&gifs); let selection = match selection_ui.run_selection_ui(&mut display) { Ok(maybe_sel) => maybe_sel, Err(e) => match e { @@ -87,14 +87,9 @@ pub fn main() { if frame_num % 5 == 0 { let event = get_key(); - if event.state != KeyState::Idle { - match event.key { - KeyCode::Esc => { - drop(buf); - return; - } - _ => (), - }; + if event.state != KeyState::Idle && event.key == KeyCode::Esc { + drop(buf); + return; }; } sleep(((frame.delay_centis as u64) * 10).saturating_sub(start)); diff --git a/user_apps/wav_player/src/main.rs b/user_apps/wav_player/src/main.rs index 8a94659..09e9d9e 100644 --- a/user_apps/wav_player/src/main.rs +++ b/user_apps/wav_player/src/main.rs @@ -4,18 +4,18 @@ extern crate alloc; use alloc::{string::String, vec::Vec}; use core::panic::PanicInfo; -use embedded_audio::{wav::Wav, AudioFile, PlatformFile, PlatformFileError}; +use embedded_audio::{AudioFile, PlatformFile, PlatformFileError, wav::Wav}; use embedded_graphics::{ - mono_font::{ascii::FONT_6X10, MonoTextStyle}, + mono_font::{MonoTextStyle, ascii::FONT_6X10}, pixelcolor::Rgb565, prelude::RgbColor, }; -use selection_ui::{draw_text_center, SelectionUi, SelectionUiError}; +use selection_ui::{SelectionUi, SelectionUiError, draw_text_center}; use userlib::{ - audio::{audio_buffer_ready, send_audio_buffer, AUDIO_BUFFER_LEN}, + audio::{AUDIO_BUFFER_LEN, audio_buffer_ready, send_audio_buffer}, display::Display, format, - fs::{file_len, list_dir, read_file, Entries}, + fs::{Entries, file_len, list_dir, read_file}, get_key, keyboard::{KeyCode, KeyState}, println, @@ -45,7 +45,7 @@ pub fn main() { let mut wavs = files.iter().map(|e| e.full_name()).collect::>(); wavs.sort(); - let mut selection_ui = SelectionUi::new(&mut wavs); + let mut selection_ui = SelectionUi::new(&wavs); let selection = match selection_ui.run_selection_ui(&mut display) { Ok(maybe_sel) => maybe_sel, Err(e) => match e { @@ -72,7 +72,7 @@ pub fn main() { .expect("Display Error"); let file_name = format!("/music/{}", wavs[selection.unwrap()]); - let file = File::new(String::from(file_name)); + let file = File::new(file_name); let mut wav = Wav::new(file).unwrap(); println!("sample rate: {}", wav.sample_rate()); println!("channels: {:?}", wav.channels() as u8); @@ -90,11 +90,8 @@ pub fn main() { } let event = get_key(); - if event.state == KeyState::Released { - match event.key { - KeyCode::Esc => return, - _ => (), - } + if event.state == KeyState::Released && event.key == KeyCode::Esc { + return; } } } diff --git a/userlib/src/lib.rs b/userlib/src/lib.rs index 6c88cb2..6db95e9 100644 --- a/userlib/src/lib.rs +++ b/userlib/src/lib.rs @@ -228,6 +228,12 @@ pub mod fs { #[derive(Clone, Copy, Debug)] pub struct Entries([[u8; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES]); + impl Default for Entries { + fn default() -> Self { + Self::new() + } + } + impl Entries { pub fn new() -> Self { Self([[0; MAX_ENTRY_NAME_LEN]; MAX_ENTRIES]) diff --git a/userlib_sys/src/lib.rs b/userlib_sys/src/lib.rs index 1e275b3..e95b296 100644 --- a/userlib_sys/src/lib.rs +++ b/userlib_sys/src/lib.rs @@ -46,9 +46,9 @@ pub struct CLayout { } #[cfg(feature = "alloc")] -impl Into for CLayout { - fn into(self) -> Layout { - unsafe { Layout::from_size_align_unchecked(self.size, self.alignment) } +impl From for Layout { + fn from(val: CLayout) -> Self { + unsafe { Layout::from_size_align_unchecked(val.size, val.alignment) } } } @@ -106,7 +106,7 @@ pub extern "C" fn get_ms() -> u64 { } #[repr(C)] -#[derive(Copy, Clone)] +#[derive(Default, Copy, Clone)] pub struct CPixel { pub x: i32, pub y: i32, @@ -123,19 +123,22 @@ impl CPixel { } } -impl Into for Pixel { - fn into(self) -> CPixel { - CPixel { - x: self.0.x, - y: self.0.y, - color: self.1.into_storage(), - } +impl From for Pixel { + fn from(value: CPixel) -> Self { + Pixel( + Point::new(value.x, value.y), + RawU16::new(value.color).into(), + ) } } -impl Into> for CPixel { - fn into(self) -> Pixel { - Pixel(Point::new(self.x, self.y), RawU16::new(self.color).into()) +impl From> for CPixel { + fn from(value: Pixel) -> Self { + CPixel { + x: value.0.x, + y: value.0.y, + color: value.1.into_storage(), + } } } @@ -171,12 +174,12 @@ pub mod keyboard { pub mods: Modifiers, } - impl Into for KeyEventC { - fn into(self) -> KeyEvent { + impl From for KeyEvent { + fn from(val: KeyEventC) -> Self { KeyEvent { - key: self.key.into(), - state: self.state, - mods: self.mods, + key: val.key.into(), + state: val.state, + mods: val.mods, } } } @@ -188,12 +191,12 @@ pub mod keyboard { pub mods: Modifiers, } - impl Into for KeyEvent { - fn into(self) -> KeyEventC { + impl From for KeyEventC { + fn from(val: KeyEvent) -> Self { KeyEventC { - key: self.key.into(), - state: self.state, - mods: self.mods, + key: val.key.into(), + state: val.state, + mods: val.mods, } } } @@ -267,9 +270,9 @@ pub mod keyboard { Unknown(u8), } - impl Into for KeyCode { - fn into(self) -> u8 { - match self { + impl From for u8 { + fn from(val: KeyCode) -> Self { + match val { KeyCode::JoyUp => 0x01, KeyCode::JoyDown => 0x02, KeyCode::JoyLeft => 0x03, From 13eb1eb75c21826ab51601d927f3355fb2742b03 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 18 Nov 2025 15:43:58 -0700 Subject: [PATCH 15/19] fix framebuffer leaving stale tiles --- kernel/src/framebuffer.rs | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/kernel/src/framebuffer.rs b/kernel/src/framebuffer.rs index 7df00b1..64469d3 100644 --- a/kernel/src/framebuffer.rs +++ b/kernel/src/framebuffer.rs @@ -261,14 +261,15 @@ impl<'a> AtomicFrameBuffer<'a> { // Check for dirty tile if self.dirty_tiles[row_start_idx + col].swap(false, Ordering::Acquire) { let run_start = col; + let mut scan_col = col; let mut run_len = 1; // Extend run while contiguous dirty tiles and within MAX_BATCH_TILES - while col + 1 < NUM_TILE_COLS + while scan_col + 1 < NUM_TILE_COLS && self.dirty_tiles[row_start_idx + col + 1].load(Ordering::Acquire) && run_len < MAX_BATCH_TILES { - col += 1; + scan_col += 1; run_len += 1; } @@ -293,6 +294,8 @@ impl<'a> AtomicFrameBuffer<'a> { &self.batch_tile_buf[..run_len * TILE_SIZE * TILE_SIZE], ) .await?; + + col = scan_col; } col += 1; @@ -346,10 +349,9 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> { } } - if changed - && let Some(rect) = dirty_rect { - self.mark_tiles_dirty(rect); - } + if changed && let Some(rect) = dirty_rect { + self.mark_tiles_dirty(rect); + } Ok(()) } @@ -411,7 +413,10 @@ impl<'a> DrawTarget for AtomicFrameBuffer<'a> { 0, self.size().width as u16 - 1, self.size().height as u16 - 1, - core::iter::repeat_n(RawU16::from(color).into_inner(), (self.size().width * self.size().height) as usize), + core::iter::repeat_n( + RawU16::from(color).into_inner(), + (self.size().width * self.size().height) as usize, + ), )?; for tile in self.dirty_tiles.iter() { From 8d3fb0b5bc88e66e30f845d53c003ad3234775f6 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 18 Nov 2025 19:20:27 -0700 Subject: [PATCH 16/19] WIP pio pwm silence --- justfile | 4 +-- kernel/src/audio.rs | 60 +++++++++++++++++++++++++++------------------ kernel/src/heap.rs | 2 +- 3 files changed, 39 insertions(+), 27 deletions(-) diff --git a/justfile b/justfile index aeb2060..29fb51a 100644 --- a/justfile +++ b/justfile @@ -1,9 +1,9 @@ target := "thumbv8m.main-none-eabihf" kernel-dev board: - cargo run --bin kernel --features {{board}} --features fps + cargo run --bin kernel --features {{board}} --features fps --features defmt kernel-release-probe board: - cargo run --bin kernel --profile release --features {{board}} --features fps + cargo run --bin kernel --profile release --features {{board}} --features fps kernel-release board: cargo build --bin kernel --release --no-default-features --features {{board}} elf2uf2-rs -d target/{{target}}/release/kernel diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index cfcad55..2a99895 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -1,6 +1,6 @@ use crate::Audio; use core::sync::atomic::{AtomicBool, Ordering}; -use embassy_futures::join::join; +use embassy_futures::{join::join, yield_now}; use embassy_rp::{ Peri, clocks::clk_sys_freq, @@ -17,16 +17,16 @@ pub const SAMPLE_RATE_HZ: u32 = 22_050; const AUDIO_BUFFER_SAMPLES: usize = 1024; const _: () = assert!(AUDIO_BUFFER_SAMPLES == userlib_sys::AUDIO_BUFFER_SAMPLES); +const SILENCE: u8 = u8::MAX / 2; + // 8bit stereo interleaved PCM audio buffers -pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [0; AUDIO_BUFFER_SAMPLES * 2]; -static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [0; AUDIO_BUFFER_SAMPLES * 2]; +pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2]; +static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2]; pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true); #[embassy_executor::task] pub async fn audio_handler(mut audio: Audio) { - const SILENCE_VALUE: u8 = u8::MAX / 2; - let prg = PioPwmAudioProgram8Bit::new(&mut audio.pio); let mut pwm_pio_left = PioPwmAudio::new(audio.dma0, &mut audio.pio, audio.sm0, audio.left, &prg); @@ -34,14 +34,16 @@ pub async fn audio_handler(mut audio: Audio) { PioPwmAudio::new(audio.dma1, &mut audio.pio, audio.sm1, audio.right, &prg); loop { - write_samples(&mut pwm_pio_left, &mut pwm_pio_right, unsafe { - &AUDIO_BUFFER_1 - }) - .await; - unsafe { &mut AUDIO_BUFFER_1 }.fill(SILENCE_VALUE); - - unsafe { core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1) }; - AUDIO_BUFFER_READY.store(true, Ordering::Release) + unsafe { + // if AUDIO_BUFFER.iter().any(|s| *s != SILENCE) { + write_samples(&mut pwm_pio_left, &mut pwm_pio_right, &AUDIO_BUFFER_1).await; + AUDIO_BUFFER_1.fill(SILENCE); + core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1); + AUDIO_BUFFER_READY.store(true, Ordering::Release) + // } else { + // yield_now().await; + // } + } } } @@ -81,17 +83,27 @@ struct PioPwmAudioProgram8Bit<'d, PIO: Instance>(LoadedProgram<'d, PIO>); /// Writes one sample to pwm as high and low time impl<'d, PIO: Instance> PioPwmAudioProgram8Bit<'d, PIO> { fn new(common: &mut Common<'d, PIO>) -> Self { - // only uses 16 bits top for high, bottom for low - // allows two samples per word + // only uses 16 bits top for pwm high, bottom for pwm low + // allows storing two samples per word let prg = pio_asm!( - "out x, 8", // pwm high time - "out y, 8", // pwm low time + ".side_set 1", + + "check:", + // "set x, 0 side 1", + // "set y, 0 side 0", + "pull ifempty noblock side 1", // gets new osr or loads 0 into x, gets second sample if osr not empty + "out x, 8 side 0", // pwm high time + "out y, 8 side 1", // pwm low time + "jmp x!=y play_sample side 0", // x & y are never equal unless osr was empty + // play silence for 10 cycles + "set x, 5 side 1", + "set y, 5 side 0", + + "play_sample:" "loop_high:", - "set pins, 1", // keep pin high - "jmp x-- loop_high", // decrement X until 0 + "jmp x-- loop_high side 1", // keep pwm high, decrement X until 0 "loop_low:", - "set pins, 0", // keep pin low - "jmp y-- loop_low", // decrement Y until 0 + "jmp y-- loop_low side 0", // keep pwm low, decrement Y until 0 ); let prg = common.load_program(&prg.program); @@ -121,15 +133,15 @@ impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> { cfg.set_set_pins(&[&pin]); cfg.fifo_join = FifoJoin::TxOnly; let shift_cfg = ShiftConfig { - auto_fill: true, + auto_fill: false, ..Default::default() }; cfg.shift_out = shift_cfg; - cfg.use_program(&prg.0, &[]); + cfg.use_program(&prg.0, &[&pin]); sm.set_config(&cfg); let target_clock = (u8::MAX as u32 + 1) * SAMPLE_RATE_HZ; - let divider = (clk_sys_freq() / (target_clock * 2)).to_fixed(); + let divider = (clk_sys_freq() / target_clock).to_fixed(); sm.set_clock_divider(divider); sm.set_enable(true); diff --git a/kernel/src/heap.rs b/kernel/src/heap.rs index 10b7710..f736cdd 100644 --- a/kernel/src/heap.rs +++ b/kernel/src/heap.rs @@ -23,7 +23,7 @@ impl Region { fn contains(&self, address: usize) -> bool { let start = self.start.load(Ordering::Relaxed); let end = start + self.size.load(Ordering::Relaxed); - (start..start + end).contains(&address) + (start..end).contains(&address) } fn new(start: usize, size: usize) -> Self { From 4df721a3c9cc3867bb73b55648ab31b7dac183d8 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Wed, 19 Nov 2025 09:35:31 -0700 Subject: [PATCH 17/19] fix audio blips when should be silent --- kernel/src/audio.rs | 81 ++++++++++++++++++++++++------------------ kernel/src/main.rs | 5 ++- kernel/src/syscalls.rs | 3 +- 3 files changed, 52 insertions(+), 37 deletions(-) diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index 2a99895..7742b1c 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -24,6 +24,14 @@ pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BU static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2]; pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true); +pub static AUDIO_BUFFER_WRITTEN: AtomicBool = AtomicBool::new(false); + +pub fn clear_audio_buffers() { + unsafe { + AUDIO_BUFFER.fill(SILENCE); + AUDIO_BUFFER_1.fill(SILENCE); + } +} #[embassy_executor::task] pub async fn audio_handler(mut audio: Audio) { @@ -35,14 +43,14 @@ pub async fn audio_handler(mut audio: Audio) { loop { unsafe { - // if AUDIO_BUFFER.iter().any(|s| *s != SILENCE) { - write_samples(&mut pwm_pio_left, &mut pwm_pio_right, &AUDIO_BUFFER_1).await; - AUDIO_BUFFER_1.fill(SILENCE); - core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1); - AUDIO_BUFFER_READY.store(true, Ordering::Release) - // } else { - // yield_now().await; - // } + if AUDIO_BUFFER_WRITTEN.load(Ordering::Acquire) { + write_samples(&mut pwm_pio_left, &mut pwm_pio_right, &AUDIO_BUFFER_1).await; + AUDIO_BUFFER_1.fill(SILENCE); + core::mem::swap(&mut AUDIO_BUFFER, &mut AUDIO_BUFFER_1); + AUDIO_BUFFER_READY.store(true, Ordering::Release) + } else { + yield_now().await; + } } } } @@ -53,29 +61,31 @@ async fn write_samples( buf: &[u8], ) { // pack two samples per word - let mut packed_buf_left: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2]; - let mut packed_buf_right: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2]; + static mut PACKED_BUF_L: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2]; + static mut PACKED_BUF_R: [u32; AUDIO_BUFFER_SAMPLES / 2] = [0; AUDIO_BUFFER_SAMPLES / 2]; - for ((pl, pr), sample) in packed_buf_left - .iter_mut() - .zip(packed_buf_right.iter_mut()) - .zip(buf.chunks(4)) - { - *pl = pack_u8_samples(sample[0], sample[2]); - *pr = pack_u8_samples(sample[1], sample[3]); + unsafe { + for ((pl, pr), sample) in PACKED_BUF_L + .iter_mut() + .zip(PACKED_BUF_R.iter_mut()) + .zip(buf.chunks(4)) + { + *pl = pack_u8_samples(sample[0], sample[2]); + *pr = pack_u8_samples(sample[1], sample[3]); + } + + let left_fut = left + .sm + .tx() + .dma_push(left.dma.reborrow(), &PACKED_BUF_L, false); + + let right_fut = right + .sm + .tx() + .dma_push(right.dma.reborrow(), &PACKED_BUF_R, false); + + join(left_fut, right_fut).await; } - - let left_fut = left - .sm - .tx() - .dma_push(left.dma.reborrow(), &packed_buf_left, false); - - let right_fut = right - .sm - .tx() - .dma_push(right.dma.reborrow(), &packed_buf_right, false); - - join(left_fut, right_fut).await; } struct PioPwmAudioProgram8Bit<'d, PIO: Instance>(LoadedProgram<'d, PIO>); @@ -88,22 +98,24 @@ impl<'d, PIO: Instance> PioPwmAudioProgram8Bit<'d, PIO> { let prg = pio_asm!( ".side_set 1", + "set x, 0 side 1", + "set y, 0 side 0", + ".wrap_target", + "check:", - // "set x, 0 side 1", - // "set y, 0 side 0", "pull ifempty noblock side 1", // gets new osr or loads 0 into x, gets second sample if osr not empty "out x, 8 side 0", // pwm high time "out y, 8 side 1", // pwm low time "jmp x!=y play_sample side 0", // x & y are never equal unless osr was empty - // play silence for 10 cycles - "set x, 5 side 1", - "set y, 5 side 0", + "set x, 1 side 1", + "set y, 1 side 0", "play_sample:" "loop_high:", "jmp x-- loop_high side 1", // keep pwm high, decrement X until 0 "loop_low:", "jmp y-- loop_low side 0", // keep pwm low, decrement Y until 0 + ".wrap" ); let prg = common.load_program(&prg.program); @@ -130,7 +142,6 @@ impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> { sm.set_pin_dirs(Direction::Out, &[&pin]); let mut cfg = Config::default(); - cfg.set_set_pins(&[&pin]); cfg.fifo_join = FifoJoin::TxOnly; let shift_cfg = ShiftConfig { auto_fill: false, diff --git a/kernel/src/main.rs b/kernel/src/main.rs index fa08eda..39c270e 100644 --- a/kernel/src/main.rs +++ b/kernel/src/main.rs @@ -35,7 +35,7 @@ mod psram; use crate::{heap::init_qmi_psram_heap, psram::init_psram_qmi}; use crate::{ - audio::audio_handler, + audio::{AUDIO_BUFFER_WRITTEN, audio_handler, clear_audio_buffers}, display::{FRAMEBUFFER, display_handler, init_display}, peripherals::{conf_peripherals, keyboard::read_keyboard_fifo}, scsi::MSC_SHUTDOWN, @@ -226,6 +226,9 @@ async fn userland_task() { // enable kernel ui { + AUDIO_BUFFER_WRITTEN.store(false, Ordering::Release); + clear_audio_buffers(); + ENABLE_UI.store(true, Ordering::Release); UI_CHANGE.signal(()); unsafe { FRAMEBUFFER.as_mut().unwrap().clear(Rgb565::BLACK).unwrap() }; diff --git a/kernel/src/syscalls.rs b/kernel/src/syscalls.rs index ca3daf2..97b8397 100644 --- a/kernel/src/syscalls.rs +++ b/kernel/src/syscalls.rs @@ -18,7 +18,7 @@ use crate::heap::HEAP; use core::alloc::GlobalAlloc; use crate::{ - audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY}, + audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY, AUDIO_BUFFER_WRITTEN}, display::FRAMEBUFFER, framebuffer::FB_PAUSED, storage::{Dir, File, SDCARD}, @@ -350,6 +350,7 @@ pub extern "C" fn send_audio_buffer(ptr: *const u8, len: usize) { if buf.len() == AUDIO_BUFFER_SAMPLES * 2 { AUDIO_BUFFER_READY.store(false, Ordering::Release); unsafe { AUDIO_BUFFER.copy_from_slice(buf) }; + AUDIO_BUFFER_WRITTEN.store(true, Ordering::Release); } else { #[cfg(feature = "defmt")] defmt::warn!( From cf8c59f0211b49f9e5b29ea5a3fe9d20212b4992 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Wed, 19 Nov 2025 10:31:34 -0700 Subject: [PATCH 18/19] cargo clippy --- userlib_sys/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/userlib_sys/src/lib.rs b/userlib_sys/src/lib.rs index e95b296..fb9e82a 100644 --- a/userlib_sys/src/lib.rs +++ b/userlib_sys/src/lib.rs @@ -217,7 +217,7 @@ pub mod keyboard { 1 => KeyState::Pressed, 2 => KeyState::Hold, 3 => KeyState::Released, - 0 | _ => KeyState::Idle, + _ => KeyState::Idle, } } } From 50341507cd6b9a30f9a81945de7d8391a19a2ab1 Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Wed, 19 Nov 2025 11:02:44 -0700 Subject: [PATCH 19/19] allow userapps to change sample rate of audio --- kernel/src/audio.rs | 42 ++++++++++++++++++++++++++++++++++++------ kernel/src/elf.rs | 3 +++ kernel/src/syscalls.rs | 11 ++++++++--- userlib_sys/src/lib.rs | 18 +++++++++++++++--- 4 files changed, 62 insertions(+), 12 deletions(-) diff --git a/kernel/src/audio.rs b/kernel/src/audio.rs index 7742b1c..088c272 100644 --- a/kernel/src/audio.rs +++ b/kernel/src/audio.rs @@ -1,5 +1,5 @@ use crate::Audio; -use core::sync::atomic::{AtomicBool, Ordering}; +use core::sync::atomic::{AtomicBool, AtomicU32, Ordering}; use embassy_futures::{join::join, yield_now}; use embassy_rp::{ Peri, @@ -23,9 +23,12 @@ const SILENCE: u8 = u8::MAX / 2; pub static mut AUDIO_BUFFER: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2]; static mut AUDIO_BUFFER_1: [u8; AUDIO_BUFFER_SAMPLES * 2] = [SILENCE; AUDIO_BUFFER_SAMPLES * 2]; +// atomics for user applications to signal changes to audio buffers pub static AUDIO_BUFFER_READY: AtomicBool = AtomicBool::new(true); pub static AUDIO_BUFFER_WRITTEN: AtomicBool = AtomicBool::new(false); +pub static AUDIO_BUFFER_SAMPLE_RATE: AtomicU32 = AtomicU32::new(SAMPLE_RATE_HZ); +/// resets audio buffers after user applications are unloaded pub fn clear_audio_buffers() { unsafe { AUDIO_BUFFER.fill(SILENCE); @@ -41,8 +44,29 @@ pub async fn audio_handler(mut audio: Audio) { let mut pwm_pio_right = PioPwmAudio::new(audio.dma1, &mut audio.pio, audio.sm1, audio.right, &prg); + // enable sms at the same time to ensure they are synced + audio.pio.apply_sm_batch(|pio| { + pio.set_enable(&mut pwm_pio_right.sm, true); + pio.set_enable(&mut pwm_pio_left.sm, true); + }); + + let mut sample_rate = SAMPLE_RATE_HZ; + loop { unsafe { + let new_sample_rate = AUDIO_BUFFER_SAMPLE_RATE.load(Ordering::Acquire); + if new_sample_rate != sample_rate { + sample_rate = new_sample_rate; + pwm_pio_left.reconfigure(sample_rate); + pwm_pio_right.reconfigure(sample_rate); + + // restart sms at the same time to ensure they are synced + audio.pio.apply_sm_batch(|pio| { + pio.restart(&mut pwm_pio_right.sm); + pio.restart(&mut pwm_pio_left.sm); + }); + } + if AUDIO_BUFFER_WRITTEN.load(Ordering::Acquire) { write_samples(&mut pwm_pio_left, &mut pwm_pio_right, &AUDIO_BUFFER_1).await; AUDIO_BUFFER_1.fill(SILENCE); @@ -130,6 +154,11 @@ struct PioPwmAudio<'d, PIO: Instance, const SM: usize> { } impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> { + fn get_sm_divider(sample_rate: u32) -> u32 { + let target_clock = (u8::MAX as u32 + 1) * sample_rate; + clk_sys_freq() / target_clock + } + fn new( dma: Peri<'d, impl Channel>, pio: &mut Common<'d, PIO>, @@ -151,17 +180,18 @@ impl<'d, PIO: Instance, const SM: usize> PioPwmAudio<'d, PIO, SM> { cfg.use_program(&prg.0, &[&pin]); sm.set_config(&cfg); - let target_clock = (u8::MAX as u32 + 1) * SAMPLE_RATE_HZ; - let divider = (clk_sys_freq() / target_clock).to_fixed(); - sm.set_clock_divider(divider); - - sm.set_enable(true); + sm.set_clock_divider(Self::get_sm_divider(SAMPLE_RATE_HZ).to_fixed()); Self { dma: dma.into(), sm, } } + + fn reconfigure(&mut self, sample_rate: u32) { + self.sm + .set_clock_divider(Self::get_sm_divider(sample_rate).to_fixed()); + } } /// packs two u8 samples into 32bit word diff --git a/kernel/src/elf.rs b/kernel/src/elf.rs index 0ab37d2..680396a 100644 --- a/kernel/src/elf.rs +++ b/kernel/src/elf.rs @@ -204,6 +204,9 @@ fn patch_syscalls( SyscallTable::ReadFile => syscalls::read_file as usize, SyscallTable::WriteFile => syscalls::write_file as usize, SyscallTable::FileLen => syscalls::file_len as usize, + SyscallTable::ReconfigureAudioSampleRate => { + syscalls::reconfigure_audio_sample_rate as usize + } SyscallTable::AudioBufferReady => syscalls::audio_buffer_ready as usize, SyscallTable::SendAudioBuffer => syscalls::send_audio_buffer as usize, }; diff --git a/kernel/src/syscalls.rs b/kernel/src/syscalls.rs index 97b8397..357d7e6 100644 --- a/kernel/src/syscalls.rs +++ b/kernel/src/syscalls.rs @@ -7,8 +7,8 @@ use embedded_sdmmc::LfnBuffer; use heapless::spsc::Queue; use userlib_sys::{ AUDIO_BUFFER_SAMPLES, Alloc, AudioBufferReady, CLayout, CPixel, Dealloc, DrawIter, FileLen, - GenRand, GetMs, ListDir, Print, ReadFile, RngRequest, SendAudioBuffer, SleepMs, WriteFile, - keyboard::*, + GenRand, GetMs, ListDir, Print, ReadFile, ReconfigureAudioSampleRate, RngRequest, + SendAudioBuffer, SleepMs, WriteFile, keyboard::*, }; #[cfg(feature = "psram")] @@ -18,7 +18,7 @@ use crate::heap::HEAP; use core::alloc::GlobalAlloc; use crate::{ - audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY, AUDIO_BUFFER_WRITTEN}, + audio::{AUDIO_BUFFER, AUDIO_BUFFER_READY, AUDIO_BUFFER_SAMPLE_RATE, AUDIO_BUFFER_WRITTEN}, display::FRAMEBUFFER, framebuffer::FB_PAUSED, storage::{Dir, File, SDCARD}, @@ -333,6 +333,11 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize { len as usize } +const _: ReconfigureAudioSampleRate = reconfigure_audio_sample_rate; +pub extern "C" fn reconfigure_audio_sample_rate(sample_rate: u32) { + AUDIO_BUFFER_SAMPLE_RATE.store(sample_rate, Ordering::Release); +} + const _: AudioBufferReady = audio_buffer_ready; pub extern "C" fn audio_buffer_ready() -> bool { AUDIO_BUFFER_READY.load(Ordering::Acquire) diff --git a/userlib_sys/src/lib.rs b/userlib_sys/src/lib.rs index fb9e82a..97ab22d 100644 --- a/userlib_sys/src/lib.rs +++ b/userlib_sys/src/lib.rs @@ -12,7 +12,7 @@ use strum::{EnumCount, EnumIter}; pub type EntryFn = fn(); -pub const SYS_CALL_TABLE_COUNT: usize = 14; +pub const SYS_CALL_TABLE_COUNT: usize = 15; const _: () = assert!(SYS_CALL_TABLE_COUNT == SyscallTable::COUNT); #[derive(Clone, Copy, EnumIter, EnumCount)] @@ -30,8 +30,9 @@ pub enum SyscallTable { ReadFile = 9, WriteFile = 10, FileLen = 11, - AudioBufferReady = 12, - SendAudioBuffer = 13, + ReconfigureAudioSampleRate = 12, + AudioBufferReady = 13, + SendAudioBuffer = 14, } #[unsafe(no_mangle)] @@ -473,6 +474,17 @@ pub extern "C" fn file_len(str: *const u8, len: usize) -> usize { } } +pub type ReconfigureAudioSampleRate = extern "C" fn(sample_rate: u32); + +#[allow(unused)] +pub fn reconfigure_audio_sample_rate(sample_rate: u32) { + unsafe { + let ptr = SYS_CALL_TABLE[SyscallTable::ReconfigureAudioSampleRate as usize]; + let f: ReconfigureAudioSampleRate = core::mem::transmute(ptr); + f(sample_rate) + } +} + pub type AudioBufferReady = extern "C" fn() -> bool; #[allow(unused)]