Programmazione multi-threading con Raspberry Pico

Post Views: 487

Con i due core presenti nel processore ARM a bordo, Pico può essere programmato per il multi-threading, l’esecuzione in parallelo di codice.

Se provieni dal mondo dello sviluppo software, sarai abituato al fatto che i tuoi programmi siano in grado di fare più di una cosa alla volta – stiamo parlando di multi-threading. Questo tipo di funzionamento si basa sul passaggio del sistema operativo da un processo all’altro, per dare l’impressione che più cose accadano contemporaneamente, o sull’utilizzo di più processori. La maggior parte dei microcontrollori non utilizza un sistema operativo per pianificare i processi e opera su un singolo processore (core). Di solito è possibile aggirare questa limitazione utilizzando gli interrupt (come abbiamo visto in precedenza),ma il Pico può effettivamente eseguire due task contemporaneamente.

Il Pico è un dispositivo dual-core (due processori), il che significa che, anche senza sistema operativo, può assegnare attività a due processi diversi, permettendogli di compiere realmente due compiti allo stesso tempo. Spesso, in un sistema embedded, è corretto eseguire due task in parallelo: un ciclo eterno può far funzionare l’interfaccia utente (aspettando la pressione dei pulsanti e visualizzando le cose) mentre l’altro controlla interattivamente le attività.

Possiamo riscrivere il nostro esempio di interrupt (articoli precedenti) per utilizzare due core: un core conta e basta, mentre l’altro attende la pressione di un pulsante.

from machine import Pin
from utime import sleep
import _thread

interruttore = Pin(10, Pin.IN, Pin.PULL_UP)

def core0():
    x = 0
    while True:
        x += 1
        print(x)
        sleep(1)

def core1():
    while True:
        if interruttore.value() == 0:
            print('interruttore premuto')
            sleep(0.1)

_thread.start_new_thread(core1, ( ))
core0()

from machine import Pin

from utime import sleep

import _thread

interruttore = Pin(10, Pin.IN, Pin.PULL_UP)

def core0():

x = 0

while True:

x += 1

print(x)

sleep(1)

def core1():

while True:

if interruttore.value() == 0:

print('interruttore premuto')

sleep(0.1)

_thread.start_new_thread(core1, ( ))

core0()

Un buon modo per separare ciò che farà ciascun core è definire una funzione in cui andrà il codice di quel core. Quindi, in questo caso, core0 inizializza una variabile contatore ( x ) su 0 e poi esegue un ciclo infinito, aggiungendo 1 a x e stampandola.

L’altro core ( core1 ) ha un secondo ciclo eterno, che stampa un messaggio quando avviene la pressione di un interruttore.

La funzione core1 viene avviata chiamando il metodo start_new_thread su _thread . Nel caso del Pico, _thread è solo un modo per identificare
il secondo core ( core 1 ).

La funzione core0 è appena stata avviata come una normale chiamata di funzione.

E’ facile notare che, anche in presenza di timer bloccanti (sleep()) all’interno di cicli infiniti, l’applicazione non subirà alcun rallentamento: infatti ciascun ramo del codice verrà eseguito ssu di un core separato.

Link utili:

Join our groups on Telegram…

… and don’t forget our social channels!

Luigi_Morelli

Definire ciò che si è non risulta mai semplice o intuitivo, in specie quando nella vita si cerca costantemente di migliorarsi, di crescere tanto professionalmente quanto emotivamente. Lavoro per contribuire al mutamento dei settori cardine della computer science e per offrire sintesi ragionate e consulenza ad aziende e pubblicazioni ICT, ma anche perche’ ciò che riesco a portare a termine mi dà soddisfazione, piacere. Così come mi piace suonare (sax, tastiere, chitarra), cantare, scrivere (ho pubblicato 350 articoli scientfici e 3 libri sinora, ma non ho concluso ciò che ho da dire), leggere, Adoro la matematica, la logica, la filosofia, la scienza e la tecnologia, ed inseguo quel concetto di homo novus rinascimentale, cercando di completare quelle sezioni della mia vita che ancora appaiono poco ricche.