From d8a5ab465ef1fb92bee1cf83004fdffba58c18fc Mon Sep 17 00:00:00 2001 From: sawyer bristol Date: Tue, 30 Sep 2025 20:27:07 -0600 Subject: [PATCH 1/7] 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 2/7] 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 3/7] 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 4/7] 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 5/7] 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 6/7] 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 7/7] 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; } } }