Gestire linee IO della Pico

La Pi Pico possiede 26 linee GPIO. Per poterle utilizzarle dobbiamo definirle come linee di ingresso o come linee di uscita, come avviene con Arduino con l’istruzione pinMode().

Realizziamo un semplice circuito come il seguente:

In questo caso le istruzioni da utilizzare fanno parte del modulo machine, quindi la prima istruzione da usare e l’importazione del modulo:

import machine

per definire un pin come uscita digitale utilizzeremo questa istruzione:

led = machine.Pin(15, machine.Pin.OUT)

L’oggetto led possiede il metodo value che permette di portare a livello alto o basso lo stato del pin:

led.value(1) # mette alto il pin 15
led.value(0) # mette basso il pin 15

Il classico blink del led si esegue con il seguente codice:

import machine
import utime

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)

while(1):
    led.value(1) # uscita a livello logico alto
    utime.sleep(1) # pausa di 1 secondo
    led.value(0) # uscita a livello logico basso
    utime.sleep(1) # pausa di 1 secondo
    

GPIO Speed Test

Dal codice precedente, eliminando l’istruzione sleep() possiamo misurare la velocita massima di commutazione del pin

import machine
import utime

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)

while(1):
    led.toggle() # mette l'uscita alta e poi bassa 

ottenendo una frequenza di commutazione di circa 60,5 KHz ma che presenta una continua variazione del livello alto dell’onda di circa  +- 1.3uS

Questo fenomeno e tipico in tutti i microcontrollori che eseguono codice interpretato, queste latenze sono intrinseche e tipicamente tollerate in questi sistemi. Per avere tempistiche certe nell’esecuzione dei programmi dobbiamo usare codici compilati e ottimizzati per l’architettura del microcontrollore.

Configurare un ingresso digitale

allo stesso modo delle istruzioni viste in precedenza possiamo definire un pin in ingresso con il seguente codice:

import machine
import utime

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)
#definisco il pin gpio 16 come ingresso
pulsante = machine.Pin(16, machine.Pin.IN)

while(1):
    if pulsante.value() == 0:
        print("pulsante premuto!")

        utime.sleep(0.2)
    
    # continuo a commutare il pin 15
    #la frequenza ora è di circa 26KHz
    led.toggle()

Utilizzare un thread

Lo svantaggio di avere delle latenze dovute alla presenza dell’interprete MicroPython può essere in parte compensato da un linguaggio ad alto livello che permette di scrivere il codice con un approccio moderno come quello dell’uso dei Thread.

Un thread è un processo che può essere eseguito in contemporanea (o quasi) con l’esecuzione di altro codice. Nell’esempio seguente il codice del thread controllerà quando premiamo il pulsante. Mentre il resto del programma continuerà a eseguirà le altre istruzioni.

import machine
import utime
import _thread

#creo una variabile globale che verrà usata in tutte le funzioni
global stato_pulsante
stato_pulsante = False

#definisco il pin gpio 15 come uscita
led = machine.Pin(15, machine.Pin.OUT)
#definisco il pin gpio 16 come ingresso
pulsante = machine.Pin(16, machine.Pin.IN)

#creo una funzione che verrà gestita dal thread
def leggi_stato_pulsante():
    global stato_pulsante
    while True:
        # se premo il pulsante cambio il valore della 
        # variabile globale
        if pulsante.value() == 0:
            stato_pulsante = True
            utime.sleep(0.2)

#creo un thread e lo associo alla funzione precedentemente creata
_thread.start_new_thread(leggi_stato_pulsante, ())

#questo è il codice del thread principale
while True:
    #controllo il valore della variabile globale
    if (stato_pulsante == True):
        print("pulsante premuto!")
        #reimposto la variabile globale a False
        global stato_pulsante
        stato_pulsante = False
    
    #continuo a eseguire la commutazione del pin 15
    led.toggle()

L’effetto di questo codice è uguale al precedente ma la scrittura del codice rimane qualitativamente migliore.

The post Come usare pin IO digitali della Pico appeared first on Esperimenti con logiche programmabili.

Nello scorso articolo abbiamo visto come configurare la Raspberry Pi Pico per poter essere programmata utilizzando il linguaggio MicroPython. In particolare abbiamo installato e configurato Thonny e caricato l’interprete MicroPython sulla scheda Pico.

In questo articolo vediamo come scrivere il nostro primo programma MicroPython e come caricarlo sulla Pico.

Colleghiamo la Pi Pico alla porta usb del computer e lanciamo l’ide Thonny. Dopo qualche istante sulla finestra shell dovremmo vedere la finestra interattiva di Python (REPL):

Utilizzando la finestra Shell è possibile eseguire direttamente dei semplici comandi. In questo modo è possibile testare delle funzioni o piccole parti di codice in modo molto veloce.

Ad esempio digitiamo sulla Shell il seguente codice e premiamo invio

print("Ciao Mondo!! Questa è la mia prima istruzione in MicroPython")

otterremo la risposta della Pico:

niente di entusiasmante! Ma comunque un semplice test per verificare che la scheda stia eseguendo il codice Python.

Scrivere un semplice programma

Nell’editor dei Thonny andiamo a scrivere delle istruzioni un po più utili. Sappiamo che il chip RP2040 è dotato di un sensore di temperature collegato all’ingresso analogico ADC4, quindi con il codice seguente andiamo a prelevare la tensione sulla linea ADC4 per poi convertirla in un valore espresso in gradi centigradi:

import machine
import utime

sensor_temp = machine.ADC(4)
conversion_factor = 3.3 / (65535)

while True:
    reading = sensor_temp.read_u16() * conversion_factor
    temperature = 27 - (reading - 0.706)/0.001721
        
    print(temperature)
    
    utime.sleep(2)

Il codice è stato copiato dal libro Get started with MicroPython.

Premiamo il pulsante Esegui lo script corrente (F5) per eseguire il programma. Thonny ci chiede dove vogliamo salvare il programma, salviamo sulla Raspberry Pi Pico:

Diamo un nome al nostro programma e premiamo sul pulsante OK:

Non appena premiamo il pulsante OK la Raspberry Pi Pico inizierà ad eseguire il programma. Sulla finestra Shell potremmo osservare il valore della temperatura rilevata dal microprocessore.

The post Caricare un programma MicroPython sulla Pi Pico appeared first on Esperimenti con logiche programmabili.

Dopo l’annuncio della produzione della Raspberry Pi Pico ho acquistato alcuni moduli per poterli testare e capire se questo nuovo microcontrollore potrà ritagliarsi una fetta importante nel mondo dei makers.

A prima vista sono rimasto molto contento del form factor della PI Pico data la flessibilità di poterlo inserire in un proprio custom pcb,  della mancanza del power led (non capisco perchè nelle schede Arduino MKR sia presente questo led che non può essere disabilitato a meno che non si proceda a dissaldarlo!) utile nei progetti a basso consumo. Inoltre un pin del microcontrollore (GPIO23) va a gestire il Power Saving del convertitore DC/DC.

Il led sulla scheda è furbamente collegato ad un pin del microcontrollore, dando la possibilità al programmatore di tenerlo acceso o meno. Non è presente un pulsante di reset integrato certamente escluso per tenere basso il costo del prodotto (per resettare la scheda è sufficiente collegare un pulsante esterno).

Un altro punto di forza della Pi Pico è la possibilità di essere programmata con due linguaggi, Python (MicroPython) o C/C++.

Con MicroPython abbiamo una curva di apprendimento rapida, subito pronti a programmare la PI Pico con ambienti di sviluppo semplici come Thonny (disponibile per diversi sistemi operativi e preinstallato su Raspberry OS).

Con C/C++ e con un completo SDK, possiamo spingerci a sviluppare programmi con performance elevate, di sfruttare tutta la potenza del microcontrollore RP2040 e di avere ambienti più sviluppo professionali come Visual Studio Code o Eclipse.

Utilizzare Thonny su Windows 10

Thonny è un ambiente di sviluppo integrato per principianti, preinstallato su Raspberry OS e disponibile anche per Windows, Mac e Linux. Dal sito thonny.org procediamo al download del software (versione 3.3.3 al momento in cui scrivo), versione per Windows. Terminato il download avviamo l’installazione lanciando l’eseguibile thonny-3.3.3.exe. Seguiamo le semplici istruzioni della procedura guidata:

Terminata l’installazione avviamo Thonny eseguendo un doppio clic sull’icona nel desktop.

Al primo avvio verrà richiesta la scelta della lingua da utilizzare nell’interfaccia grafica, selezioniamo quella che preferiamo e andiamo avanti premendo il pulsante Let’s go!:

Dopo qualche istante vi ritroverete davanti l’interfaccia grafica di Thonny:

Caricare MycroPython sulla Pi Pico

Per programmare la Pi Pico con Thonny è necessario caricare l’interprete MicroPython. Questa procedura è stata eseguita utilizzando Windows 10 versione 20H2. Colleghiamo la PI Pico alla porta usb del computer. La scheda viene riconosciuta dal sistema e viene avviata una procedura automatica di configurazione.

Clicchiamo, col pulsante destro del mouse, sul pulsante Start, dal menu contestuale scegliamo la voce Gestione Dispositivi. Sotto la voce Altri dispositivi dovrà essere presente l’elemento con nome RP2 Boot.

In caso contrario rimuoviamo la scheda dalla porta usb, teniamo premuto il pulsante BOOTSEL della Pico e contemporaneamente ricolleghiamo la scheda alla porta usb.

Rilasciate il pulsante BOOTSEL.

In Esplora risorse dovremmo anche avere una nuova unita disco chiamata RPI-RP2.

Portiamoci sul sito raspberrypi.org, nella sezione dedicata alla Pico scarichiamo Micropython cliccando sul pulsante Download UF2 File:

Ora copiamo il file pico_micropython_20210121.uf2 sul disco RPI-RP2. Attendiamo la copia del file e il riavvio della scheda Pi Pico.

Controllando in gestione dispositivi dovremmo avere che la voce Altri Dispositivi-> RP2 Boot viene eliminata e sostituita da una nuova periferica COM, nel mio caso la COM22

Configurazione dell’ambiente di sviluppo

La versione 3.3.3 di Thonny ha già preinstallato il plug-in per comunicare con la Raspberry Pi Pico. E’ sufficiente selezionare l’interprete dal menu posizionato in basso a destra della finestra principale:

Selezionando la voce MicroPython (Raspberry Pi Pico) permetterà a Thonny di collegarsi alla Pico attivando la comunicazione seriale con la Pico e mostrando l’interfaccia interattiva REPL.

Per selezionare la scheda e la porta COM manualmente è possibile farlo dal menu Esegui->Seleziona Interprete:

Nel tab Interprete possiamo selezionare l’interprete e la porta COM della scheda Pi Pico:

Nel prossimo articolo vedremmo come caricare il primo programma sulla Pi Pico

The post Programmare la Raspberry Pi Pico con MicroPython appeared first on Esperimenti con logiche programmabili.