rp2 — funzionalità specifiche dell’RP2040

Il modulo rp2 contiene funzioni e classi specifiche dell’RP2040, come utilizzato nel Raspberry Pi Pico.

Consulta il datasheet Python dell’RP2040 per maggiori informazioni e pico-micropython-examples per codice di esempio.

Istruzioni del linguaggio assembly del PIO

Le macchine a stati PIO vengono programmate in un linguaggio assembly personalizzato con nove istruzioni fondamentali della macchina PIO. In MicroPython, le routine assembly PIO vengono scritte come funzione Python con il decoratore @rp2.asm_pio(), e usano la sintassi Python. Tali routine supportano le variabili e l’aritmetica standard di Python, oltre alle seguenti funzioni personalizzate che codificano le istruzioni PIO e guidano l’assemblatore. Vedi la sez. 3.4 del datasheet dell’RP2040 per ulteriori dettagli.

wrap_target()

Specifica la posizione in cui l’esecuzione continua dopo il wrapping del programma. Per impostazione predefinita questo è l’inizio della routine PIO.

wrap()

Specifica la posizione in cui il programma termina ed esegue il wrap. Se questa direttiva non viene usata, allora viene aggiunta automaticamente alla fine della routine PIO. Il wrapping non costa alcun ciclo di esecuzione.

label(label)

Definisce un’etichetta chiamata label nella posizione corrente. label può essere una stringa o un intero.

word(instr, label=None)

Inserisce una parola arbitraria di 16 bit nell’output assemblato.

  • instr: il valore di 16 bit

  • label: se fornita, cerca l’etichetta ed esegue l’OR logico del valore dell’etichetta con instr

jmp(…)

Questa istruzione ha due forme:

jmp(label)

  • label: etichetta verso cui saltare incondizionatamente

jmp(cond, label)

  • cond: la condizione da verificare, una tra:

    • not_x, not_y: vera se il registro è zero

    • x_dec, y_dec: vera se il registro è diverso da zero, ed esegue un post-decremento

    • x_not_y: vera se X è diverso da Y

    • pin: vera se il pin di ingresso è impostato

    • not_osre: vera se l’OSR non è vuoto (non ha raggiunto la sua soglia)

  • label: etichetta verso cui saltare se la condizione è vera

wait(polarity, src, index)

Blocca, in attesa di un livello alto/basso su un pin o su una linea IRQ.

  • polarity: 0 o 1, se attendere un valore basso o alto

  • src: uno tra: gpio (pin assoluto), pin (pin relativo all’argomento in_base della StateMachine), irq

  • index: 0-31, l’indice per src

in_(src, bit_count)

Esegue lo shift dei dati da src verso l’ISR.

  • src: uno tra: pins, x, y, null, isr, osr

  • bit_count: numero di bit di cui eseguire lo shift in ingresso (1-32)

out(dest, bit_count)

Esegue lo shift dei dati dall’OSR verso dest.

  • dest: uno tra: pins, x, y, pindirs, pc, isr, exec

  • bit_count: numero di bit di cui eseguire lo shift in uscita (1-32)

push(…)

Esegue il push dell’ISR nella FIFO RX, poi azzera l’ISR. Questa istruzione ha le seguenti forme:

  • push()

  • push(block)

  • push(noblock)

  • push(iffull)

  • push(iffull, block)

  • push(iffull, noblock)

Se viene usato block allora l’istruzione si blocca se la FIFO RX è piena. Il comportamento predefinito è di bloccare. Se viene usato iffull allora esegue il push solo se il conteggio dello shift in ingresso ha raggiunto la sua soglia.

pull(…)

Esegue il pull dalla FIFO TX verso l’OSR. Questa istruzione ha le seguenti forme:

  • pull()

  • pull(block)

  • pull(noblock)

  • pull(ifempty)

  • pull(ifempty, block)

  • pull(ifempty, noblock)

Se viene usato block allora l’istruzione si blocca se la FIFO TX è vuota. Il comportamento predefinito è di bloccare. Se viene usato ifempty allora esegue il pull solo se il conteggio dello shift in uscita ha raggiunto la sua soglia.

mov(dest, src)

Sposta in dest il valore da src.

  • dest: uno tra: pins, x, y, exec, pc, isr, osr

  • src: uno tra: pins, x, y, null, status, isr, osr; questo argomento può essere opzionalmente modificato racchiudendolo in invert() o reverse() (ma non entrambi insieme)

irq(…)

Imposta o azzera un flag IRQ. Questa istruzione ha due forme:

irq(index)

  • index: 0-7, oppure da rel(0) a rel(7)

irq(mode, index)

  • mode: uno tra: block, clear

  • index: 0-7, oppure da rel(0) a rel(7)

Se viene usato block allora l’istruzione si blocca finché il flag non viene azzerato da un’altra entità. Se viene usato clear allora il flag viene azzerato invece di essere impostato. Gli indici IRQ relativi aggiungono l’ID della macchina a stati all’indice IRQ con addizione modulo 4. Gli IRQ 0-3 sono visibili dal processore, mentre i 4-7 sono interni alle macchine a stati.

set(dest, data)

Imposta dest con il valore data.

  • dest: pins, x, y, pindirs

  • data: valore (0-31)

nop()

Questa è una pseudoistruzione che si assembla in mov(y, y) e non ha alcun effetto collaterale.

.side(value)

Questo è un modificatore che può essere applicato a qualsiasi istruzione, ed è usato per controllare i valori dei pin side-set.

  • value: il valore (i bit) da emettere sui pin side-set

.delay(value)

Questo è un modificatore che può essere applicato a qualsiasi istruzione, e specifica per quanti cicli ritardare dopo l’esecuzione dell’istruzione.

  • value: cicli di ritardo, 0-31 (il valore massimo è ridotto se vengono usati i pin side-set)

[value]

Questo è un modificatore ed è equivalente a .delay(value).

Classi