max/embassy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rp/pio: PioStateMachine{Instance, => ,Instance}

Browse Source 
next step: get rid of the insance trait entirely
This commit is contained in:
pennae 2023-05-03 09:42:42 +02:00
parent 79985f0036
commit 906d2b2db7
6 changed files with 42 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
embassy-rp/src/pio.rs
View File

@ -97,13 +97,13 @@ pub(crate) unsafe fn init() {
/// Future that waits for TX-FIFO to become writable /// Future that waits for TX-FIFO to become writable
#[must_use = "futures do nothing unless you `.await` or poll them"] #[must_use = "futures do nothing unless you `.await` or poll them"]
pub struct FifoOutFuture<'a, PIO: PioInstance, SM: PioStateMachine + Unpin> { pub struct FifoOutFuture<'a, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> {
sm: &'a mut SM, sm: &'a mut SM,
pio: PhantomData<PIO>, pio: PhantomData<PIO>,
value: u32, value: u32,
} }
impl<'a, PIO: PioInstance, SM: PioStateMachine + Unpin> FifoOutFuture<'a, PIO, SM> { impl<'a, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> FifoOutFuture<'a, PIO, SM> {
pub fn new(sm: &'a mut SM, value: u32) -> Self { pub fn new(sm: &'a mut SM, value: u32) -> Self {
FifoOutFuture { FifoOutFuture {
sm, sm,
@ -113,7 +113,7 @@ impl<'a, PIO: PioInstance, SM: PioStateMachine + Unpin> FifoOutFuture<'a, PIO, S
} }
} }
impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Future for FifoOutFuture<'d, PIO, SM> { impl<'d, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> Future for FifoOutFuture<'d, PIO, SM> {
type Output = (); type Output = ();
fn poll(self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { fn poll(self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
//debug!("Poll {},{}", PIO::PIO_NO, SM); //debug!("Poll {},{}", PIO::PIO_NO, SM);
@ -133,7 +133,7 @@ impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Future for FifoOutFuture
} }
} }
impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Drop for FifoOutFuture<'d, PIO, SM> { impl<'d, PIO: PioInstance, SM: PioStateMachineInstance + Unpin> Drop for FifoOutFuture<'d, PIO, SM> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
PIO::PIO.irqs(0).inte().write_clear(|m| { PIO::PIO.irqs(0).inte().write_clear(|m| {
@ -145,12 +145,12 @@ impl<'d, PIO: PioInstance, SM: PioStateMachine + Unpin> Drop for FifoOutFuture<'
/// Future that waits for RX-FIFO to become readable /// Future that waits for RX-FIFO to become readable
#[must_use = "futures do nothing unless you `.await` or poll them"] #[must_use = "futures do nothing unless you `.await` or poll them"]
pub struct FifoInFuture<'a, PIO: PioInstance, SM: PioStateMachine> { pub struct FifoInFuture<'a, PIO: PioInstance, SM: PioStateMachineInstance> {
sm: &'a mut SM, sm: &'a mut SM,
pio: PhantomData<PIO>, pio: PhantomData<PIO>,
} }
impl<'a, PIO: PioInstance, SM: PioStateMachine> FifoInFuture<'a, PIO, SM> { impl<'a, PIO: PioInstance, SM: PioStateMachineInstance> FifoInFuture<'a, PIO, SM> {
pub fn new(sm: &'a mut SM) -> Self { pub fn new(sm: &'a mut SM) -> Self {
FifoInFuture { FifoInFuture {
sm, sm,
@ -159,7 +159,7 @@ impl<'a, PIO: PioInstance, SM: PioStateMachine> FifoInFuture<'a, PIO, SM> {
} }
} }
impl<'d, PIO: PioInstance, SM: PioStateMachine> Future for FifoInFuture<'d, PIO, SM> { impl<'d, PIO: PioInstance, SM: PioStateMachineInstance> Future for FifoInFuture<'d, PIO, SM> {
type Output = u32; type Output = u32;
fn poll(mut self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> { fn poll(mut self: FuturePin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
//debug!("Poll {},{}", PIO::PIO_NO, SM); //debug!("Poll {},{}", PIO::PIO_NO, SM);
@ -178,7 +178,7 @@ impl<'d, PIO: PioInstance, SM: PioStateMachine> Future for FifoInFuture<'d, PIO,
} }
} }
impl<'d, PIO: PioInstance, SM: PioStateMachine> Drop for FifoInFuture<'d, PIO, SM> { impl<'d, PIO: PioInstance, SM: PioStateMachineInstance> Drop for FifoInFuture<'d, PIO, SM> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
PIO::PIO.irqs(0).inte().write_clear(|m| { PIO::PIO.irqs(0).inte().write_clear(|m| {
@ -312,11 +312,11 @@ impl<'l, PIO: PioInstance> Pin<'l, PIO> {
} }
} }
pub struct PioStateMachineInstance<'d, PIO: PioInstance, const SM: usize> { pub struct PioStateMachine<'d, PIO: PioInstance, const SM: usize> {
pio: PhantomData<&'d PIO>, pio: PhantomData<&'d PIO>,
} }
impl<'d, PIO: PioInstance, const SM: usize> Drop for PioStateMachineInstance<'d, PIO, SM> { impl<'d, PIO: PioInstance, const SM: usize> Drop for PioStateMachine<'d, PIO, SM> {
fn drop(&mut self) { fn drop(&mut self) {
unsafe { unsafe {
PIO::PIO.ctrl().write_clear(|w| w.set_sm_enable(1 << SM)); PIO::PIO.ctrl().write_clear(|w| w.set_sm_enable(1 << SM));
@ -325,13 +325,13 @@ impl<'d, PIO: PioInstance, const SM: usize> Drop for PioStateMachineInstance<'d,
} }
} }
impl<'d, PIO: PioInstance, const SM: usize> sealed::PioStateMachine for PioStateMachineInstance<'d, PIO, SM> { impl<'d, PIO: PioInstance, const SM: usize> sealed::PioStateMachineInstance for PioStateMachine<'d, PIO, SM> {
type Pio = PIO; type Pio = PIO;
const SM: usize = SM; const SM: usize = SM;
} }
impl<'d, PIO: PioInstance, const SM: usize> PioStateMachine for PioStateMachineInstance<'d, PIO, SM> {} impl<'d, PIO: PioInstance, const SM: usize> PioStateMachineInstance for PioStateMachine<'d, PIO, SM> {}
pub trait PioStateMachine: sealed::PioStateMachine + Sized + Unpin { pub trait PioStateMachineInstance: sealed::PioStateMachineInstance + Sized + Unpin {
fn restart(&mut self) { fn restart(&mut self) {
let mask = 1u8 << Self::SM; let mask = 1u8 << Self::SM;
unsafe { unsafe {
@ -892,10 +892,10 @@ impl<'d, PIO: PioInstance> PioCommon<'d, PIO> {
pub struct Pio<'d, PIO: PioInstance> { pub struct Pio<'d, PIO: PioInstance> {
pub common: PioCommon<'d, PIO>, pub common: PioCommon<'d, PIO>,
pub sm0: PioStateMachineInstance<'d, PIO, 0>, pub sm0: PioStateMachine<'d, PIO, 0>,
pub sm1: PioStateMachineInstance<'d, PIO, 1>, pub sm1: PioStateMachine<'d, PIO, 1>,
pub sm2: PioStateMachineInstance<'d, PIO, 2>, pub sm2: PioStateMachine<'d, PIO, 2>,
pub sm3: PioStateMachineInstance<'d, PIO, 3>, pub sm3: PioStateMachine<'d, PIO, 3>,
} }
impl<'d, PIO: PioInstance> Pio<'d, PIO> { impl<'d, PIO: PioInstance> Pio<'d, PIO> {
@ -907,10 +907,10 @@ impl<'d, PIO: PioInstance> Pio<'d, PIO> {
instructions_used: 0, instructions_used: 0,
pio: PhantomData, pio: PhantomData,
}, },
sm0: PioStateMachineInstance { pio: PhantomData }, sm0: PioStateMachine { pio: PhantomData },
sm1: PioStateMachineInstance { pio: PhantomData }, sm1: PioStateMachine { pio: PhantomData },
sm2: PioStateMachineInstance { pio: PhantomData }, sm2: PioStateMachine { pio: PhantomData },
sm3: PioStateMachineInstance { pio: PhantomData }, sm3: PioStateMachine { pio: PhantomData },
} }
} }
} }
@ -944,7 +944,7 @@ fn on_pio_drop<PIO: PioInstance>() {
mod sealed { mod sealed {
use super::*; use super::*;
pub trait PioStateMachine { pub trait PioStateMachineInstance {
type Pio: super::PioInstance; type Pio: super::PioInstance;
const SM: usize; const SM: usize;

20
embassy-rp/src/pio_instr_util.rs
View File

@ -1,8 +1,8 @@
use pio::{InSource, InstructionOperands, JmpCondition, OutDestination, SetDestination}; use pio::{InSource, InstructionOperands, JmpCondition, OutDestination, SetDestination};
use crate::pio::PioStateMachine; use crate::pio::PioStateMachineInstance;
pub fn set_x<SM: PioStateMachine>(sm: &mut SM, value: u32) { pub fn set_x<SM: PioStateMachineInstance>(sm: &mut SM, value: u32) {
const OUT: u16 = InstructionOperands::OUT { const OUT: u16 = InstructionOperands::OUT {
destination: OutDestination::X, destination: OutDestination::X,
bit_count: 32, bit_count: 32,
@ -12,7 +12,7 @@ pub fn set_x<SM: PioStateMachine>(sm: &mut SM, value: u32) {
sm.exec_instr(OUT); sm.exec_instr(OUT);
} }
pub fn get_x<SM: PioStateMachine>(sm: &mut SM) -> u32 { pub fn get_x<SM: PioStateMachineInstance>(sm: &mut SM) -> u32 {
const IN: u16 = InstructionOperands::IN { const IN: u16 = InstructionOperands::IN {
source: InSource::X, source: InSource::X,
bit_count: 32, bit_count: 32,
@ -22,7 +22,7 @@ pub fn get_x<SM: PioStateMachine>(sm: &mut SM) -> u32 {
sm.pull_rx() sm.pull_rx()
} }
pub fn set_y<SM: PioStateMachine>(sm: &mut SM, value: u32) { pub fn set_y<SM: PioStateMachineInstance>(sm: &mut SM, value: u32) {
const OUT: u16 = InstructionOperands::OUT { const OUT: u16 = InstructionOperands::OUT {
destination: OutDestination::Y, destination: OutDestination::Y,
bit_count: 32, bit_count: 32,
@ -32,7 +32,7 @@ pub fn set_y<SM: PioStateMachine>(sm: &mut SM, value: u32) {
sm.exec_instr(OUT); sm.exec_instr(OUT);
} }
pub fn get_y<SM: PioStateMachine>(sm: &mut SM) -> u32 { pub fn get_y<SM: PioStateMachineInstance>(sm: &mut SM) -> u32 {
const IN: u16 = InstructionOperands::IN { const IN: u16 = InstructionOperands::IN {
source: InSource::Y, source: InSource::Y,
bit_count: 32, bit_count: 32,
@ -43,7 +43,7 @@ pub fn get_y<SM: PioStateMachine>(sm: &mut SM) -> u32 {
sm.pull_rx() sm.pull_rx()
} }
pub fn set_pindir<SM: PioStateMachine>(sm: &mut SM, data: u8) { pub fn set_pindir<SM: PioStateMachineInstance>(sm: &mut SM, data: u8) {
let set: u16 = InstructionOperands::SET { let set: u16 = InstructionOperands::SET {
destination: SetDestination::PINDIRS, destination: SetDestination::PINDIRS,
data, data,
@ -52,7 +52,7 @@ pub fn set_pindir<SM: PioStateMachine>(sm: &mut SM, data: u8) {
sm.exec_instr(set); sm.exec_instr(set);
} }
pub fn set_pin<SM: PioStateMachine>(sm: &mut SM, data: u8) { pub fn set_pin<SM: PioStateMachineInstance>(sm: &mut SM, data: u8) {
let set: u16 = InstructionOperands::SET { let set: u16 = InstructionOperands::SET {
destination: SetDestination::PINS, destination: SetDestination::PINS,
data, data,
@ -61,7 +61,7 @@ pub fn set_pin<SM: PioStateMachine>(sm: &mut SM, data: u8) {
sm.exec_instr(set); sm.exec_instr(set);
} }
pub fn set_out_pin<SM: PioStateMachine>(sm: &mut SM, data: u32) { pub fn set_out_pin<SM: PioStateMachineInstance>(sm: &mut SM, data: u32) {
const OUT: u16 = InstructionOperands::OUT { const OUT: u16 = InstructionOperands::OUT {
destination: OutDestination::PINS, destination: OutDestination::PINS,
bit_count: 32, bit_count: 32,
@ -70,7 +70,7 @@ pub fn set_out_pin<SM: PioStateMachine>(sm: &mut SM, data: u32) {
sm.push_tx(data); sm.push_tx(data);
sm.exec_instr(OUT); sm.exec_instr(OUT);
} }
pub fn set_out_pindir<SM: PioStateMachine>(sm: &mut SM, data: u32) { pub fn set_out_pindir<SM: PioStateMachineInstance>(sm: &mut SM, data: u32) {
const OUT: u16 = InstructionOperands::OUT { const OUT: u16 = InstructionOperands::OUT {
destination: OutDestination::PINDIRS, destination: OutDestination::PINDIRS,
bit_count: 32, bit_count: 32,
@ -80,7 +80,7 @@ pub fn set_out_pindir<SM: PioStateMachine>(sm: &mut SM, data: u32) {
sm.exec_instr(OUT); sm.exec_instr(OUT);
} }
pub fn exec_jmp<SM: PioStateMachine>(sm: &mut SM, to_addr: u8) { pub fn exec_jmp<SM: PioStateMachineInstance>(sm: &mut SM, to_addr: u8) {
let jmp: u16 = InstructionOperands::JMP { let jmp: u16 = InstructionOperands::JMP {
address: to_addr, address: to_addr,
condition: JmpCondition::Always, condition: JmpCondition::Always,

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

@ -9,7 +9,7 @@ use embassy_rp::pio_instr_util;
use embassy_rp::relocate::RelocatedProgram; use embassy_rp::relocate::RelocatedProgram;
use {defmt_rtt as _, panic_probe as _}; use {defmt_rtt as _, panic_probe as _};
fn setup_pio_task_sm0(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstance<PIO0, 0>, pin: impl PioPin) { fn setup_pio_task_sm0(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachine<PIO0, 0>, pin: impl PioPin) {
// Setup sm0 // Setup sm0
// Send data serially to pin // Send data serially to pin
@ -37,7 +37,7 @@ fn setup_pio_task_sm0(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstanc
} }
#[embassy_executor::task] #[embassy_executor::task]
async fn pio_task_sm0(mut sm: PioStateMachineInstance<'static, PIO0, 0>) { async fn pio_task_sm0(mut sm: PioStateMachine<'static, PIO0, 0>) {
sm.set_enable(true); sm.set_enable(true);
let mut v = 0x0f0caffa; let mut v = 0x0f0caffa;
@ -48,7 +48,7 @@ async fn pio_task_sm0(mut sm: PioStateMachineInstance<'static, PIO0, 0>) {
} }
} }
fn setup_pio_task_sm1(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstance<PIO0, 1>) { fn setup_pio_task_sm1(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachine<PIO0, 1>) {
// Setupm sm1 // Setupm sm1
// Read 0b10101 repeatedly until ISR is full // Read 0b10101 repeatedly until ISR is full
@ -67,7 +67,7 @@ fn setup_pio_task_sm1(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstanc
} }
#[embassy_executor::task] #[embassy_executor::task]
async fn pio_task_sm1(mut sm: PioStateMachineInstance<'static, PIO0, 1>) { async fn pio_task_sm1(mut sm: PioStateMachine<'static, PIO0, 1>) {
sm.set_enable(true); sm.set_enable(true);
loop { loop {
let rx = sm.wait_pull().await; let rx = sm.wait_pull().await;
@ -75,7 +75,7 @@ async fn pio_task_sm1(mut sm: PioStateMachineInstance<'static, PIO0, 1>) {
} }
} }
fn setup_pio_task_sm2(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstance<PIO0, 2>) { fn setup_pio_task_sm2(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachine<PIO0, 2>) {
// Setup sm2 // Setup sm2
// Repeatedly trigger IRQ 3 // Repeatedly trigger IRQ 3
@ -99,7 +99,7 @@ fn setup_pio_task_sm2(pio: &mut PioCommon<PIO0>, sm: &mut PioStateMachineInstanc
} }
#[embassy_executor::task] #[embassy_executor::task]
async fn pio_task_sm2(mut sm: PioStateMachineInstance<'static, PIO0, 2>) { async fn pio_task_sm2(mut sm: PioStateMachine<'static, PIO0, 2>) {
sm.set_enable(true); sm.set_enable(true);
loop { loop {
sm.wait_irq(3).await; sm.wait_irq(3).await;

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

@ -4,7 +4,7 @@
use defmt::info; use defmt::info;
use embassy_executor::Spawner; use embassy_executor::Spawner;
use embassy_futures::join::join; use embassy_futures::join::join;
use embassy_rp::pio::{Pio, PioStateMachine, ShiftDirection}; use embassy_rp::pio::{Pio, PioStateMachineInstance, ShiftDirection};
use embassy_rp::relocate::RelocatedProgram; use embassy_rp::relocate::RelocatedProgram;
use embassy_rp::{pio_instr_util, Peripheral}; use embassy_rp::{pio_instr_util, Peripheral};
use {defmt_rtt as _, panic_probe as _}; use {defmt_rtt as _, panic_probe as _};

2
examples/rp/src/bin/pio_hd44780.rs
View File

@ -64,7 +64,7 @@ async fn main(_spawner: Spawner) {
pub struct HD44780<'l> { pub struct HD44780<'l> {
dma: PeripheralRef<'l, AnyChannel>, dma: PeripheralRef<'l, AnyChannel>,
sm: PioStateMachineInstance<'l, PIO0, 0>, sm: PioStateMachine<'l, PIO0, 0>,
buf: [u8; 40], buf: [u8; 40],
} }

4
examples/rp/src/bin/ws2812-pio.rs
View File

@ -13,11 +13,11 @@ use embassy_time::{Duration, Timer};
use smart_leds::RGB8; use smart_leds::RGB8;
use {defmt_rtt as _, panic_probe as _}; use {defmt_rtt as _, panic_probe as _};
pub struct Ws2812<'d, P: PioInstance, const S: usize> { pub struct Ws2812<'d, P: PioInstance, const S: usize> {
sm: PioStateMachineInstance<'d, P, S>, sm: PioStateMachine<'d, P, S>,
} }
impl<'d, P: PioInstance, const S: usize> Ws2812<'d, P, S> { impl<'d, P: PioInstance, const S: usize> Ws2812<'d, P, S> {
pub fn new(mut pio: PioCommon<'d, P>, mut sm: PioStateMachineInstance<'d, P, S>, pin: impl PioPin) -> Self { pub fn new(mut pio: PioCommon<'d, P>, mut sm: PioStateMachine<'d, P, S>, pin: impl PioPin) -> Self {
// Setup sm0 // Setup sm0
// prepare the PIO program // prepare the PIO program