Datasheet

•
IRQ flag set/clear/status
Each state machine, along with its supporting hardware, occupies approximately the same silicon area as a standard
serial interface block, such as an SPI or I2C controller. However, PIO state machines can be configured and reconfigured
dynamically to implement numerous different interfaces.
Making state machines programmable in a software-like manner, rather than a fully configurable logic fabric like a CPLD,
allows more hardware interfaces to be offered in the same cost and power envelope. This also presents a more familiar
programming model, and simpler tool flow, to those who wish to exploit PIO’s full flexibility by programming it directly,
rather than using a premade interface from the PIO library.
PIO is highly performant as well as flexible, thanks to a carefully selected set of fixed-function hardware inside each state
machine. The DPI examples output 360 Mb/s during the active scanline period when running from a 48 MHz system
clock. In this example, one state machine is handling frame/scanline timing and generating the pixel clock, while another
is handling the pixel data, and unpacking run-length-encoded scanlines.
State machines' inputs and outputs are mapped to up to 32 GPIOs (limited to 30 GPIOs for RP2040), and all state
machines have independent, simultaneous access to any GPIO. For example, the standard UART code allows TX, RX, CTS
and RTS to be any four arbitrary GPIOs, and I2C permits the same for SDA and SCL. The amount of freedom available
depends on how exactly a given PIO program chooses to use PIO’s pin mapping resources, but at the minimum, an
interface can be freely shifted up or down by some number of GPIOs.
3.2. Programmer’s Model
The four state machines execute from a shared instruction memory. System software loads programs into this memory,
configures the state machines and IO mapping, and then sets the state machines running. PIO programs come from
various sources: assembled directly by the user, drawn from the PIO library, or generated programmatically by user
software.
From this point on, state machines are generally autonomous, and system software interacts through DMA, interrupts and
control registers, as with other peripherals on RP2040. For more complex interfaces, PIO provides a small but flexible set
of primitives which allow system software to be more hands-on with state machine control flow.
Figure 37. State
machine overview.
Data flows in and out
through a pair of
FIFOs. The state
machine executes a
program which
transfers data
between these FIFOs,
a set of internal
registers, and the pins.
The clock divider can
reduce the state
machine’s execution
speed by a constant
factor.
3.2.1. PIO Programs
PIO state machines execute short, binary programs.
Programs for common interfaces, such as UART, SPI, or I2C, are available in the PIO library, so in many cases, it is not
necessary to write PIO programs. However, the PIO is much more flexible when programmed directly, supporting a wide
variety of interfaces which may not have been foreseen by its designers.
The PIO has a total of nine instructions: JMP, WAIT, IN, OUT, PUSH, PULL, MOV, IRQ, and SET. See Section 3.4 for details on these
instructions.
RP2040 Datasheet
3.2. Programmer’s Model 307