itsscb/embassy
1
0
Fork 0
mirror of https://github.com/embassy-rs/embassy.git synced 2025-09-28 04:40:39 +00:00
Code Issues Packages Projects Releases Wiki Activity

rp/pio: update pio-rs crate, reexport it so users don't get version mismatches.

Browse Source
This commit is contained in:
Dario Nieuwenhuis 2025-02-10 00:03:49 +01:00
parent dcf0868dd0
commit 52dfefb632
21 changed files with 45 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cyw43-pio/Cargo.toml
View File

@ -12,8 +12,6 @@ documentation = "https://docs.embassy.dev/cyw43-pio"
[dependencies]
cyw43 = { version = "0.3.0", path = "../cyw43" }
embassy-rp = { version = "0.3.0", path = "../embassy-rp" }
pio-proc = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
pio = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
fixed = "1.23.1"
defmt = { version = "0.3", optional = true }

2
cyw43-pio/src/lib.rs
View File

@ -8,11 +8,11 @@ use core::slice;
use cyw43::SpiBusCyw43;
use embassy_rp::dma::Channel;
use embassy_rp::gpio::{Drive, Level, Output, Pull, SlewRate};
use embassy_rp::pio::program::pio_asm;
use embassy_rp::pio::{Common, Config, Direction, Instance, Irq, PioPin, ShiftDirection, StateMachine};
use embassy_rp::{Peripheral, PeripheralRef};
use fixed::types::extra::U8;
use fixed::FixedU32;
use pio_proc::pio_asm;
/// SPI comms driven by PIO.
pub struct PioSpi<'d, PIO: Instance, const SM: usize, DMA> {

3
embassy-rp/Cargo.toml
View File

@ -164,8 +164,7 @@ embedded-hal-1 = { package = "embedded-hal", version = "1.0" }
embedded-hal-async = { version = "1.0" }
embedded-hal-nb = { version = "1.0" }
pio-proc = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
pio = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
pio = { git = "https://github.com/rp-rs/pio-rs", rev = "506a51b9bc135845e8544a0debd75847b73754dc" }
rp2040-boot2 = "0.3"
document-features = "0.2.10"
sha2-const-stable = "0.1"

3
embassy-rp/src/pio/mod.rs
View File

@ -20,6 +20,9 @@ use crate::{pac, peripherals, RegExt};
mod instr;
#[doc(inline)]
pub use pio as program;
/// Wakers for interrupts and FIFOs.
pub struct Wakers([AtomicWaker; 12]);

4
embassy-rp/src/pio_programs/hd44780.rs
View File

@ -15,7 +15,7 @@ pub struct PioHD44780CommandWordProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioHD44780CommandWordProgram<'a, PIO> {
/// Load the program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
r#"
.side_set 1 opt
.origin 20
@ -46,7 +46,7 @@ impl<'a, PIO: Instance> PioHD44780CommandSequenceProgram<'a, PIO> {
/// Load the program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
// many side sets are only there to free up a delay bit!
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
r#"
.origin 27
.side_set 1

2
embassy-rp/src/pio_programs/i2s.rs
View File

@ -16,7 +16,7 @@ pub struct PioI2sOutProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioI2sOutProgram<'a, PIO> {
/// Load the program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
".side_set 2",
" set x, 14 side 0b01", // side 0bWB - W = Word Clock, B = Bit Clock
"left_data:",

8
embassy-rp/src/pio_programs/onewire.rs
View File

@ -1,6 +1,6 @@
//! OneWire pio driver
use crate::pio::{self, Common, Config, Instance, LoadedProgram, PioPin, ShiftConfig, ShiftDirection, StateMachine};
use crate::pio::{Common, Config, Instance, LoadedProgram, PioPin, ShiftConfig, ShiftDirection, StateMachine};
/// This struct represents an onewire driver program
pub struct PioOneWireProgram<'a, PIO: Instance> {
@ -10,7 +10,7 @@ pub struct PioOneWireProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioOneWireProgram<'a, PIO> {
/// Load the program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
r#"
.wrap_target
again:
@ -60,11 +60,11 @@ impl<'a, PIO: Instance> PioOneWireProgram<'a, PIO> {
}
/// Pio backed OneWire driver
pub struct PioOneWire<'d, PIO: pio::Instance, const SM: usize> {
pub struct PioOneWire<'d, PIO: Instance, const SM: usize> {
sm: StateMachine<'d, PIO, SM>,
}
impl<'d, PIO: pio::Instance, const SM: usize> PioOneWire<'d, PIO, SM> {
impl<'d, PIO: Instance, const SM: usize> PioOneWire<'d, PIO, SM> {
/// Create a new instance the driver
pub fn new(
common: &mut Common<'d, PIO>,

2
embassy-rp/src/pio_programs/pwm.rs
View File

@ -21,7 +21,7 @@ pub struct PioPwmProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioPwmProgram<'a, PIO> {
/// Load the program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
".side_set 1 opt"
"pull noblock side 0"
"mov x, osr"

8
embassy-rp/src/pio_programs/rotary_encoder.rs
View File

@ -3,7 +3,9 @@
use fixed::traits::ToFixed;
use crate::gpio::Pull;
use crate::pio::{self, Common, Config, FifoJoin, Instance, LoadedProgram, PioPin, ShiftDirection, StateMachine};
use crate::pio::{
Common, Config, Direction as PioDirection, FifoJoin, Instance, LoadedProgram, PioPin, ShiftDirection, StateMachine,
};
/// This struct represents an Encoder program loaded into pio instruction memory.
pub struct PioEncoderProgram<'a, PIO: Instance> {
@ -13,7 +15,7 @@ pub struct PioEncoderProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioEncoderProgram<'a, PIO> {
/// Load the program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!("wait 1 pin 1", "wait 0 pin 1", "in pins, 2", "push",);
let prg = pio::pio_asm!("wait 1 pin 1", "wait 0 pin 1", "in pins, 2", "push",);
let prg = common.load_program(&prg.program);
@ -39,7 +41,7 @@ impl<'d, T: Instance, const SM: usize> PioEncoder<'d, T, SM> {
let mut pin_b = pio.make_pio_pin(pin_b);
pin_a.set_pull(Pull::Up);
pin_b.set_pull(Pull::Up);
sm.set_pin_dirs(pio::Direction::In, &[&pin_a, &pin_b]);
sm.set_pin_dirs(PioDirection::In, &[&pin_a, &pin_b]);
let mut cfg = Config::default();
cfg.set_in_pins(&[&pin_a, &pin_b]);

2
embassy-rp/src/pio_programs/stepper.rs
View File

@ -16,7 +16,7 @@ pub struct PioStepperProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioStepperProgram<'a, PIO> {
/// Load the program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
"pull block",
"mov x, osr",
"pull block",

4
embassy-rp/src/pio_programs/uart.rs
View File

@ -19,7 +19,7 @@ pub struct PioUartTxProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioUartTxProgram<'a, PIO> {
/// Load the uart tx program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
r#"
.side_set 1 opt
@ -99,7 +99,7 @@ pub struct PioUartRxProgram<'a, PIO: Instance> {
impl<'a, PIO: Instance> PioUartRxProgram<'a, PIO> {
/// Load the uart rx program into the given pio
pub fn new(common: &mut Common<'a, PIO>) -> Self {
let prg = pio_proc::pio_asm!(
let prg = pio::pio_asm!(
r#"
; Slightly more fleshed-out 8n1 UART receiver which handles framing errors and
; break conditions more gracefully.

2
examples/rp/Cargo.toml
View File

@ -55,8 +55,6 @@ embedded-storage = { version = "0.3" }
static_cell = "2.1"
portable-atomic = { version = "1.5", features = ["critical-section"] }
log = "0.4"
pio-proc = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
pio = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
rand = { version = "0.8.5", default-features = false }
embedded-sdmmc = "0.7.0"

7
examples/rp/src/bin/pio_async.rs
View File

@ -6,6 +6,7 @@ use defmt::info;
use embassy_executor::Spawner;
use embassy_rp::bind_interrupts;
use embassy_rp::peripherals::PIO0;
use embassy_rp::pio::program::pio_asm;
use embassy_rp::pio::{Common, Config, InterruptHandler, Irq, Pio, PioPin, ShiftDirection, StateMachine};
use fixed::traits::ToFixed;
use fixed_macro::types::U56F8;
@ -19,7 +20,7 @@ fn setup_pio_task_sm0<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
// Setup sm0
// Send data serially to pin
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
".origin 16",
"set pindirs, 1",
".wrap_target",
@ -53,7 +54,7 @@ fn setup_pio_task_sm1<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
// Setupm sm1
// Read 0b10101 repeatedly until ISR is full
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
//
".origin 8",
"set x, 0x15",
@ -83,7 +84,7 @@ fn setup_pio_task_sm2<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
// Setup sm2
// Repeatedly trigger IRQ 3
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
".origin 0",
".wrap_target",
"set x,10",

3
examples/rp/src/bin/pio_dma.rs
View File

@ -6,6 +6,7 @@ use defmt::info;
use embassy_executor::Spawner;
use embassy_futures::join::join;
use embassy_rp::peripherals::PIO0;
use embassy_rp::pio::program::pio_asm;
use embassy_rp::pio::{Config, InterruptHandler, Pio, ShiftConfig, ShiftDirection};
use embassy_rp::{bind_interrupts, Peripheral};
use fixed::traits::ToFixed;
@ -32,7 +33,7 @@ async fn main(_spawner: Spawner) {
..
} = Pio::new(pio, Irqs);
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
".origin 0",
"set pindirs,1",
".wrap_target",

2
examples/rp23/Cargo.toml
View File

@ -55,8 +55,6 @@ embedded-storage = { version = "0.3" }
static_cell = "2.1"
portable-atomic = { version = "1.5", features = ["critical-section"] }
log = "0.4"
pio-proc = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
pio = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
rand = { version = "0.8.5", default-features = false }
embedded-sdmmc = "0.7.0"

7
examples/rp23/src/bin/pio_async.rs
View File

@ -6,6 +6,7 @@ use defmt::info;
use embassy_executor::Spawner;
use embassy_rp::bind_interrupts;
use embassy_rp::peripherals::PIO0;
use embassy_rp::pio::program::pio_asm;
use embassy_rp::pio::{Common, Config, InterruptHandler, Irq, Pio, PioPin, ShiftDirection, StateMachine};
use fixed::traits::ToFixed;
use fixed_macro::types::U56F8;
@ -19,7 +20,7 @@ fn setup_pio_task_sm0<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
// Setup sm0
// Send data serially to pin
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
".origin 16",
"set pindirs, 1",
".wrap_target",
@ -53,7 +54,7 @@ fn setup_pio_task_sm1<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
// Setupm sm1
// Read 0b10101 repeatedly until ISR is full
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
//
".origin 8",
"set x, 0x15",
@ -83,7 +84,7 @@ fn setup_pio_task_sm2<'a>(pio: &mut Common<'a, PIO0>, sm: &mut StateMachine<'a,
// Setup sm2
// Repeatedly trigger IRQ 3
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
".origin 0",
".wrap_target",
"set x,10",

3
examples/rp23/src/bin/pio_dma.rs
View File

@ -6,6 +6,7 @@ use defmt::info;
use embassy_executor::Spawner;
use embassy_futures::join::join;
use embassy_rp::peripherals::PIO0;
use embassy_rp::pio::program::pio_asm;
use embassy_rp::pio::{Config, InterruptHandler, Pio, ShiftConfig, ShiftDirection};
use embassy_rp::{bind_interrupts, Peripheral};
use fixed::traits::ToFixed;
@ -32,7 +33,7 @@ async fn main(_spawner: Spawner) {
..
} = Pio::new(pio, Irqs);
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
".origin 0",
"set pindirs,1",
".wrap_target",

3
examples/rp23/src/bin/pio_rotary_encoder_rxf.rs
View File

@ -8,6 +8,7 @@ use defmt::info;
use embassy_executor::Spawner;
use embassy_rp::gpio::Pull;
use embassy_rp::peripherals::PIO0;
use embassy_rp::pio::program::pio_asm;
use embassy_rp::{bind_interrupts, pio};
use embassy_time::Timer;
use fixed::traits::ToFixed;
@ -46,7 +47,7 @@ impl<'d, T: Instance, const SM: usize> PioEncoder<'d, T, SM> {
sm.set_pin_dirs(pio::Direction::In, &[&pin_a, &pin_b]);
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
"start:"
// encoder count is stored in X
"mov isr, x"

2
tests/rp/Cargo.toml
View File

@ -33,8 +33,6 @@ embedded-io-async = { version = "0.6.1" }
embedded-storage = { version = "0.3" }
static_cell = "2"
portable-atomic = { version = "1.5", features = ["critical-section"] }
pio-proc = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
pio = { git = "https://github.com/rp-rs/pio-rs", rev = "fa586448b0b223217eec8c92c19fe6823dd04cc4" }
rand = { version = "0.8.5", default-features = false }
[profile.dev]

3
tests/rp/src/bin/pio_irq.rs
View File

@ -6,6 +6,7 @@ use defmt::info;
use embassy_executor::Spawner;
use embassy_rp::bind_interrupts;
use embassy_rp::peripherals::PIO0;
use embassy_rp::pio::program::pio_asm;
use embassy_rp::pio::{Config, InterruptHandler, Pio};
use {defmt_rtt as _, panic_probe as _};
@ -24,7 +25,7 @@ async fn main(_spawner: Spawner) {
..
} = Pio::new(pio, Irqs);
let prg = pio_proc::pio_asm!(
let prg = pio_asm!(
"irq set 0",
"irq wait 0",
"irq set 1",

16
tests/rp/src/bin/pio_multi_load.rs
View File

@ -6,6 +6,7 @@ use defmt::info;
use embassy_executor::Spawner;
use embassy_rp::bind_interrupts;
use embassy_rp::peripherals::PIO0;
use embassy_rp::pio::program::pio_asm;
use embassy_rp::pio::{Config, InterruptHandler, LoadError, Pio};
use {defmt_rtt as _, panic_probe as _};
@ -27,7 +28,7 @@ async fn main(_spawner: Spawner) {
} = Pio::new(pio, Irqs);
// load with explicit origin works
let prg1 = pio_proc::pio_asm!(
let prg1 = pio_asm!(
".origin 4"
"nop",
"nop",
@ -46,15 +47,14 @@ async fn main(_spawner: Spawner) {
assert_eq!(loaded1.wrap.target, 4);
// load without origin chooses a free space
let prg2 = pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 1", "nop", "nop",);
let prg2 = pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 1", "nop", "nop",);
let loaded2 = common.load_program(&prg2.program);
assert_eq!(loaded2.origin, 14);
assert_eq!(loaded2.wrap.source, 23);
assert_eq!(loaded2.wrap.target, 14);
// wrapping around the end of program space automatically works
let prg3 =
pio_proc::pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 2",);
let prg3 = pio_asm!("nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "nop", "irq 2",);
let loaded3 = common.load_program(&prg3.program);
assert_eq!(loaded3.origin, 24);
assert_eq!(loaded3.wrap.source, 3);
@ -88,13 +88,13 @@ async fn main(_spawner: Spawner) {
// instruction memory is full now. all loads should fail.
{
let prg = pio_proc::pio_asm!(".origin 0", "nop");
let prg = pio_asm!(".origin 0", "nop");
match common.try_load_program(&prg.program) {
Err(LoadError::AddressInUse(0)) => (),
_ => panic!("program loaded when it shouldn't"),
};
let prg = pio_proc::pio_asm!("nop");
let prg = pio_asm!("nop");
match common.try_load_program(&prg.program) {
Err(LoadError::InsufficientSpace) => (),
_ => panic!("program loaded when it shouldn't"),
@ -106,13 +106,13 @@ async fn main(_spawner: Spawner) {
common.free_instr(loaded3.used_memory);
}
{
let prg = pio_proc::pio_asm!(".origin 0", "nop");
let prg = pio_asm!(".origin 0", "nop");
match common.try_load_program(&prg.program) {
Ok(_) => (),
_ => panic!("program didn't loaded when it shouldn"),
};
let prg = pio_proc::pio_asm!("nop");
let prg = pio_asm!("nop");
match common.try_load_program(&prg.program) {
Ok(_) => (),
_ => panic!("program didn't loaded when it shouldn"),