Struct rp2040_hal::pio::StateMachine

pub struct StateMachine<SM: ValidStateMachine, State> { /* private fields */ }

PIO State Machine with an associated program.

Implementations

impl<SM: ValidStateMachine, State> StateMachine<SM, State>

pub fn uninit( self, _rx: Rx<SM>, _tx: Tx<SM> ) -> (UninitStateMachine<SM>, InstalledProgram<SM::PIO>)

Stops the state machine if it is still running and returns its program.

The program can be uninstalled to free space once it is no longer used by any state machine.

pub fn instruction_address(&self) -> u32

The address of the instruction currently being executed.

pub fn set_instruction(&mut self, instruction: u16)

👎Deprecated: Renamed to exec_instruction

Execute the instruction immediately.

pub fn exec_instruction(&mut self, instruction: Instruction)

Execute the instruction immediately.

If an instruction written to INSTR stalls, it is stored in the same instruction latch used by OUT EXEC and MOV EXEC, and will overwrite an in-progress instruction there. If EXEC instructions are used, instructions written to INSTR must not stall.

pub fn stalled(&self) -> bool

Check if the current instruction is stalled.

pub fn clear_fifos(&mut self)

Clear both TX and RX FIFOs

pub fn drain_tx_fifo(&mut self)

Drain Tx fifo.

pub fn set_clock_divisor(&mut self, divisor: f32)

Change the clock divider of a state machine.

Changing the clock divider of a running state machine is allowed and guaranteed to not cause any glitches, but the exact timing of clock pulses during the change is not specified.

pub fn clock_divisor_fixed_point(&mut self, int: u16, frac: u8)

Change the clock divider of a state machine using a 16.8 fixed point value.

Changing the clock divider of a running state machine is allowed and guaranteed to not cause any glitches, but the exact timing of clock pulses during the change is not specified.

impl<SM: ValidStateMachine> StateMachine<SM, Stopped>

pub fn start(self) -> StateMachine<SM, Running>

Starts execution of the selected program.

pub fn set_pins(&mut self, pins: impl IntoIterator<Item = (u8, PinState)>)

Sets the pin state for the specified pins.

The user has to make sure that they do not select any pins that are in use by any other state machines of the same PIO block.

The iterator’s item are pairs of (pin_number, pin_state).

pub fn set_pindirs(&mut self, pindirs: impl IntoIterator<Item = (u8, PinDir)>)

Set pin directions.

The user has to make sure that they do not select any pins that are in use by any other state machines of the same PIO block.

The iterator’s item are pairs of (pin_number, pin_dir).

impl<P: PIOExt, SM: StateMachineIndex> StateMachine<(P, SM), Stopped>

pub fn synchronize_with<'sm, SM2: StateMachineIndex>( &'sm mut self, _other_sm: &'sm mut StateMachine<(P, SM2), Stopped> ) -> Synchronize<'sm, (P, SM)>

Restarts the clock dividers for the specified state machines.

As a result, the clock will be synchronous for the state machines, which is a precondition for synchronous operation.

The function returns an object that, once destructed, restarts the clock dividers. This object allows further state machines to be added if more than two shall be synchronized.

Example

sm0.synchronize_with(sm1).and_with(sm2);

impl<P: PIOExt, SM: StateMachineIndex, State> StateMachine<(P, SM), State>

pub fn with<SM2: StateMachineIndex>( self, other_sm: StateMachine<(P, SM2), State> ) -> StateMachineGroup2<P, SM, SM2, State>

Create a group of state machines, which can be started/stopped synchronously

impl<SM: ValidStateMachine> StateMachine<SM, Running>

pub fn stop(self) -> StateMachine<SM, Stopped>

Stops execution of the selected program.

pub fn restart(&mut self)

Restarts the execution of the selected program from its wrap target.

Trait Implementations

impl<SM: ValidStateMachine + Send, State> Send for StateMachine<SM, State>