Sperimentare con Raspberry Pi Pico è ancora più facile e divertente con le Maker PI RP2040 e Maker Pi Pico!

Pubblicato il -
Questo articolo potrebbe contenere link di affiliazione, ovvero link a pagine in cui, se viene effettuato un'acquisto, potrebbero generare una commissione a settorezero ma comunque senza incidere sul costo finale dell'oggetto acquistato. E' un modo per non avere pubblicità invasiva (che, se non avete notato, abbiamo rimosso) e nel contempo garantire al sito di continuare ad esistere.

In questo articolo vi parlo di due nuovissime board di sviluppo nate nella Silicon Valley dell’est per sperimentare con il Raspberry RP2040  e con il CircuitPython

Sponsor

Le schede oggetto dell’articolo, sono state gentilmente offerte da Cytron Technologies. Le opinioni qui riportate sono del tutto personali e non influenzate in alcun modo dal fornitore del prodotto.

La Cytron Technologies

La Cytron Technologies è stata fondata nel 2004. Il nome prende spunto dal pianeta Cybertron dei Transformers. Anche loro hanno iniziato con i microcontrollori PIC, in particolare cominciarono con una scheda di sviluppo chiamata SK40A, basata sui microcontrollori PIC dell’epoca a 40 pin: il PIC16F877A e il PIC18F452. La sede principale, dove realizzano le schede, si trova a Penang in Malesia, che è stata definita la Silicon Valley dell’Est e hanno distributori un po’ in tutto il mondo. Alcuni loro prodotti, come La Maker Uno, La Maker Uno Plus e la Maker Line, sono distribuiti in Italia da Futura Elettronica. Sul loro sito, poi, oltre ad i loro prodotti distribuiscono anche schede di sviluppo ed accessori realizzati da altri marchi.

Lasciatemi dire che questa azienda sta crescendo sempre di più grazie alle loro idee innovative e ai nuovi prodotti che sfornano di continuo, realizzati sempre con una cura e qualità eccellenti. Personalmente il motto che utilizzano “Trust I’m a Maker” a me piace tantissimo. 

Abbiamo già incontrato questi ragazzi in un articolo precedente in cui vi ho illustrato un po’ la Maker Uno, la scheda compatibile Arduino UNO che ho scelto per il mio robottino Arlok perchè economica, bella da vedere e con delle caratteristiche nuove e fresche. Adesso, oltre a tutti i prodotti che hanno a catalogo, hanno realizzato due schede davvero geniali basate sul nuovo microcontrollore Raspberry RP2040 e che adesso andiamo a vedere.

Maker Pi Pico vs Maker Pi RP2040

Le due schede di cui vi voglio parlare sono la Maker Pi Pico e la Maker Pi RP2040. Sono due schede distinte, nate per sperimentare con il microcontrollore RP2040 di Raspberry Foundation e il linguaggio di programmazione CircuitPython (ma anche MicroPython) e che si rivolgono un po’ a tutti ma soprattutto al mercato dei Makers e delle scuole. La prima (Maker Pi Pico) è decisamente nata per la sperimentazione a 360° perchè include tutta una serie di caratteristiche on-board che la rendono davvero una scheda tuttofare, mentre la seconda (Maker Pi RP2040) è perfetta per chi vuole costruire un Robot o qualsiasi altro dispositivo dotato di piccoli motori e/o servocomandi.

Le schede hanno una qualità sbalorditiva: serigrafie perfette, saldature eccellenti, design sublime, non ho davvero niente da segnalare… zero… e questo mi fa strano perchè normalmente sono molto pignolo e trovo i minimi difetti. Non voglio aggiungere che il costo di queste schede è davvero irrisorio (meno di 10 dollari a scheda!).

Entrambe fanno parte della serie Maker della Cytron che è una serie di board di sviluppo pensate soprattutto per il mercato educational e per chi vuole avere tutto a portata di mano. Personalmente la cosa che apprezzo di più in questa serie di board è il fatto che sono chiaramente riportati i GPIO su tutti i pinout, con anche le funzioni alternative: per me questa è una condizione necessaria per lo sviluppo perchè non bisogna perdere tempo con i fogli stampati in mano a cercare sugli schemi , vedrete nelle successive foto cosa intendo. Ora analizziamo le due schede nel dettaglio per poi passare alla parte di programmazione in CircuitPython.

Maker Pi Pico

Questa board è disponibile in due versioni: una versione ha gli header femmina per innestare al di sopra un Raspberry Pi Pico (non fornito di default), questa board è anche chiamata Maker Pi Pico Base (link), mentre una seconda versione ha già un Raspberry Pi Pico saldato a bordo tramite le castellature (link).

Esternamente tra le due c’è una sola differenza: la base, sulla quale metterete voi un Raspberry Pi Pico in vostro possesso, ha, per l’innesto, due doppie file di headers femmina, per cui affianco al Raspberry Pi Pico vi ritroverete un header femmina vuoto che riporta all’esterno i singoli pin (e quindi per eventuali collegamenti all’esterno userete cavetti jumper che terminano col maschio), l’altra, quella con il Raspberry Pi Pico già saldato sopra, riporta invece per ogni pin un header maschio, quindi userete eventualmente cavetti jumper che terminano con il connettore femmina.

Di seguito un’immagine che illustra il layout della scheda (l’immagine è relativa alla versione con il Pico già saldato, per cui gli headers laterali ritratti sono maschio):

Questa scheda ha le seguenti caratteristiche:

  • 6 connettori Grove
  • Slot per MicroSD (da GP10 a 15)
  • Connettore jack femmina stereo 3.5″ (per audio out, su GP18 e 19)
  • Buzzer piezoelettrico disinseribile tramite switch (GP18)
  • Led bufferizzati su tutti gli IO (non interferiscono con altre cose collegate sui pin)
  • Tutti gli IO del PICO sono riportati all’esterno sugli header laterali al PICO
  • 3 pulsanti a disposizione dell’utente (GP20, 21, 22)
  • 1 LED RGB (WS2812, GP28)
  • 1 socket per un modulo ESP-01 (GP16 e 17) => questo permette di fornire connettività WiFi alla scheda
  • Pulsante di Reset
  • Connettore di Debug

Per chi ancora non conosce cosa sono i connettori Grove (Grove, non groove come molti continuano a scrivere e pronunciare): si tratta di uno standard inventato da Seed Studio che si è diffuso a maccha d’olio nel mondo dei makers. Il connettore è proprietario e non è possibile adattare altri tipi di connettori come Molex o JST, più avanti fornisco dei link dove recuperare questi connettori.

Queste sono le foto avanti e indietro della scheda, ora capirete cosa intendevo quando parlavo della questione del pinout, potete notare come non si abbia alcun bisogno di stare con schemi e tabelle alla mano quando si sperimenta:

front / rear della Maker Pi Pico. L’attenzione ai dettagli è eccezionale!

La scheda, se acquistate la versione con il Pico presadato, ha già caricato il CircuitPython insieme ad una demo che illustra tutte le funzionalità della scheda. Se acquistate la versione senza Pico e volete caricare la demo in oggetto, la trovate sul repo Github della Cytron per la Maker Pi Pico: andate nella cartella Out-of-the-box Demo Code > CircuitPython e copiate tutto il contenuto di tale cartella nella radice dell’unità di massa del Pico.

Conviene sempre scaricare tutto il repository cliccando sul tasto Code > Download Zip

Per la demo, se avete un display OLED 128×64 I2C basato sul controllore SSD1306, potete anche collegarlo al connettore Grove n°5 utilizzando un cavetto Grove/dupont femmina oppure, se non siete in possesso di cavi Grove, potete usare dei cavetti jumper direttamente sugli headers esterni ai lati del Pico.

out of the box demo: meglio avere un display oled 128×64 da collegare sul connettore Grove 4, ma non è indispensabile

Con il cavo Grove il filo bianco è SDA (GP6) e quello giallo è SCL (GP7). Altrimenti esistono anche i display OLED che escono già col connettore Grove.

Questo video illustra il funzionamento della demo:

La figata, come vedete, è che la demo utilizza anche l’uscita audio out riproducendo un file WAV caricato sulla memoria di massa della Pico (avete bisogno di casse amplificate) e utilizza anche la MicroSD se ce l’avete installata (usate una MicroSD da 4GB formattata in FAT32).

Queste caratteristiche ne fanno, secondo il mio parere una scheda molto adatta alla sperimentazione audio. Addirittura, dalla versione 6.2 di CircuitPython, è presente una libreria per decodificare i files MP3 e Cytron ha approntato una demo che fa il play di un file MP3 dalla microSD senza altre schede in mezzo! La decodifica viene eseguita direttamente dall’RP2040: figata assoluta. C’è anche una demo che permette di realizzare una batteria Midi.

La scheda è molto economica e ben fatta e viene fornita senza cavi Grove, a differenza della RP2040. Nella confezione è presente un piccolo cheatsheet:

Contenuto confezione Maker Pi Pico

Trovo anche molto simpatico e geniale che la scatola stessa abbia le aperture davanti per il connettore jack da 3.5″ e dietro per il connettore USB (sopra se avete montato voi la Pico, sotto se avete preso la versione con il Pico presaldato), il che permette di realizzare un’applicazione musicale utilizzando la stessa scatola come contenitore!

La scatola della Maker Pi Pico può anche essere usata come contenitore per un progetto audio dato che presenta le aperture per l’uscita Jack e connettore USB. Geniale!

Maker Pi RP2040

Questa scheda ha un chip RP2040 presaldato sulla scheda con una memoria flash da 2MB (perfettamente uguale al Raspberry Pi Pico di serie). Di seguito l’immagine che illustra il layout della scheda:

Questa scheda, come dicevo più sopra, è pensata per applicazioni di robotica in quanto ha un ponte H per due motori a bassa tensione e un header per 4 servocomandi. In più nella scatola di questa board troveremo anche 4 cavetti jumper da Grove a Dupont femmina nonchè un piccolo cacciavite a stella per svitare gli screw terminal e 4 piedini adesivi in gomma.

Contenuto confezione Maker Pi RP2040. Oltre alla board sono presenti 4 cavetti jumper da Grove a Dupont femmina, 4 piedini adesivi in gomma e un piccolo cacciavite a croce

Vediamo tutte le caratteristiche di questa fantastica board:

  • 7 connettori Grove
  • Buzzer piezoelettrico disinseribile tramite switch (GP22)
  • Led bufferizzati su 13 GPIO (si trovano al centro in una sezione Digital IO Status)
  • 2 pulsanti a disposizione dell’utente (GP20, GP21)
  • 2 LED RGB (WS2812, GP18)
  • Pulsante di Reset
  • Circuito di alimentazione versatile:
    • Interruttore ON/OFF
    • Selezione automatica alimentazione: porta USB / Batteria LiPo 1S / Tensione dall’esterno sullo screw terminal Vin (ammessa da 3.6 a 6V)
    • Circuito di ricarica per la LiPo con protezione
  • Ponte H (MX1508) per il pilotaggio di una coppia di motori DC o di singolo motore stepper (GP8-9 + GP10-11)
  • 4 connettori per servocomandi (GP12÷15)

Queste sono le foto avanti/dietro della scheda:

front / rear della Maker Pi RP2040

Sia il motore / i motori collegati al ponte H che i servocomandi (che ora indico tutti semplicemente come “motori”) vengono alimentati con la sorgente di alimentazione che fornite: se alimentate con USB, allora i motori saranno alimentati a 5V, se alimentate su Vin con 6V, allora i motori saranno alimentati a 6V, se alimentate con la LiPo… allora saranno alimentati a 3.7/4.2V insomma con la tensione di batteria. Il ponte H è in grado di fornire massimo 1A a canale, quindi i motori più potenti che potete collegare possono essere 6V 1A (ammettendo che volete alimentare con Vin).

La batteria, in particolare, viene caricata soltanto dalla porta USB, non da Vin, e non è consigliato utilizzare contemporaneamente USB e Vin sebbene il circuito sia fatto in modo na non creare nessun problema.

Se avevo fatto notare la figata della scatola della Maker Pi Pico, che ha le aperture per i connettori esterni, qui invece devo segnalarne un’altra, di figata assurda: intorno alla scheda sono presenti 4 fori più grandi compatibili con i Lego®!

Questa cosa personalmente mi fa impazzire. E’ bellissima e apre la mente verso nuove possibilità, soprattutto pensando che con la stampa 3D potremmo realizzare degli alloggiamenti per motori e servo da incastrare sulle piastre Lego®. In realtà gli stud dei Lego® entreranno un po’ forzati, aiutatevi magari con una pinza di quelle grosse ruotando il pezzo, senza fare troppa forza altrimenti spaccate sia le costruzioni che la board. Altrimenti potete utilizzare il pezzo chiamato “pin”, ovvero quel cilindretto che si usa nei Lego Technik: quello ci entra alla perfezione.

La scheda viene fornita con il CircuitPython già caricato e una demo. Anche qui la demo la trovate nel repository dedicato alla Raspberry Pi RP2040 (Examples > CircuitPython > Out-of-the-box Demo Code). Il seguente video illustra il funzionamento della demo:

Anche qui ci sono già pronte delle belle demo come questo Object Sensing, che muove un sensore TOF, tramite un servocomando, alla ricerca di un oggetto. Altrimenti se volete spostarvi verso Arduino IDE anzichè CircuitPython, qui c’è un esempio di realizzazione del famoso Robot OTTO con questa scheda.

Si, perchè se non volete utilizzare CircuitPython o MicroPython, potete utilizzare il C nativo dell’RP2040 oppure Arduino IDE.

Tabella comparativa tra le due schede

In questa tabella, presente sul sito della Cytron, e scaricabile anche come PDF, sono riassunte le differenze tra le due schede oggetto di questo articolo:

CircuitPython vs MicroPython

In alcuni miei articoli precedenti vi ho parlato del MicroPython, come installarlo ed utilizzarlo sulla Raspberry Pi Pico: tutte quelle cose rimangono ancora valide se volete utilizzare il MicroPython. Cytron, invece, sulla Maker Pi RP2040 e sulla Maker Pi Pico completa installa di default il CircuitPython. I due linguaggi sono molto simili, il CircuitPython è un fork del MicroPython realizzato da Adafruit per fare in modo che l’utilizzo del Python sui microcontrollori sia ancora più semplice di quello che abbiamo già visto. Le risposte alla domanda Quali sono le differenze tra CircuitPython e MicroPython vengono tutte fuori dall’apposita pagina su Github realizzata dalla stessa Adafruit.

Qui ne illustro soltanto alcune, di differenze, che ritengo forse le più significative per quello che mi riguarda, per tutte le altre potete fare riferimento al link di cui sopra o andare al paragrafo links:

  • Una delle differenze più evidenti è che quando sulla board è installato il CircuitPython, la scheda viene sempre riconosciuta, da subito, come memoria di massa: compare una unità sulla quale possiamo trascinare gli script in python e le librerie, con il MicroPython bisogna invece appoggiarsi ad un tool esterno (Thonny) per caricare programmi e librerie dato che la scheda non viene vista come unità di storage.
  • La porta USB nativa è supportata: da CircuitPython possiamo realizzare programmi che emulano mouse e tastiera, con il MicroPython (attualmente, non si sa se verrà implementato in futuro) non è possibile fare questa cosa.
  • La documentazione è davvero ampia e Adafruit ha rilasciato una marea di librerie per fare qualsiasi cosa, tutte in formato mpy, che come abbiamo già visto, è una sorta di file intermedio pre-compilato, che occupa molto meno spazio sull’unità.
  • Il CircuitPython attualmente non supporta gli interrupts e Adafruit non sa se/quando li introdurrà, mentre MicroPython li supporta.

Installazione CircuitPython

Questa operazione, chiaramente, non va fatta sulle vostre schede se avete acquistato la Maker Pi RP2040 (che ha il chip sulla scheda) o la Maker Pi Pico con già saldato il Pico dato che hanno già il CircuitPython installato nonchè il programma demo precaricato. Scrivo la procedura nel caso aveste una Raspberry Pi Pico nuova/riciclata da mettere sulla Maker Pi Pico o nel caso in cui incontriate problemi e dopo una formattazione del Pico vogliate reinstallarlo.

Nella pagina ufficiale del CircuitPython, relativa al microcontrollore RP2040, è possibile scaricare l’interprete in formato UF2 del CircuitPython, sia in versione stabile (primo link) che in versione sperimentale.

Per la sola Maker Pi RP2040, Cytron ha realizzato un’installazione del CircuitPython personalizzata, che include già tutte le librerie necessarie per lavorare con i robots. Questa versione, al momento in cui scrivo l’articolo, è ancora in fase alpha e la potete scaricare qui.

Bisogna, come abbiamo già visto per il MicroPython:

  • Togliere alimentazione alla scheda
  • Tenere premuto il pulsante Bootsel sul Raspberry Pi Pico o il pulsante Boot sulla Maker Pi RP2040
  • Dare alimentazione
  • Aspettare un secondo e rilasciare il pulsante

Se la scheda non viene riconosciuta, Adafruit dice di installare i suoi drivers.

Nelle risorse di sistema compare una nuova unità chiamata RPI-RP2:

Trascinare in questa unità il file UF2 scaricato. La scheda verrà riavviata in automatico.

Con questa procedura potete passare tranquillamente anche da MicroPython a CircuitPython e ho fatto una prova per capire cosa accade ad eventuali nostri script presenti sulla Pico quando si passa da un interprete all’altro: ho caricato degli script sulla memoria di massa con il CircuitPython, poi ho installato MicroPython e ho quindi caricato altri script tramite Thonny (se avete letto il mio articolo sul MicroPython sapete che con questo linguaggio non c’è memoria di massa e si ricorre ad un’applicazione per caricare i files). Ho quindi rimesso CircuitPython e mi sono ritrovato tutti i files che avevo caricato prima sulla memoria di massa! Ho provato a rimettere quindi MicroPython e… mi sono ritrovato i files che avevo caricato con Thonny! E’ chiaro quindi che i due linguaggi hanno la propria tabella di allocazione dei files e che questa operazione non può andare avanti all’infinito, soprattutto se abbiamo parecchi files perchè prima o poi quelli di un linguaggio sovrascriveranno quelli dell’altro… Pertanto se desideriamo fare questi esperimenti è sempre bene salvarci prima i nostri script sul pc! Ricordo che potete, in ogni caso, portare a zero la memoria del Pico utilizzando l’apposito UF2 che formatta la memoria flash: leggete questo paragrafo nell’articolo sul MicroPython.

Al riavvio, come dicevo sopra, il CircuitPython rende la scheda subito visibile come unità esterna a differenza del MicroPython. Nell’unità, che si chiama CIRCUITPY, ci ritroveremo questo:

Nella cartella lib andranno copiate le librerie, operazione che descriverò al paragrafo successivo. Il file code.py è il file che viene eseguito all’avvio (quando si da tensione alla board). Il file da eseguire all’avvio può chiamarsi nei seguenti modi:

  1. code.txt
  2. code.py
  3. main.py
  4. main.txt

Questi nomi verranno cercati, in sequenza, sulla board, per cui se avete un file che si chiama code.txt e un altro che si chiama main.py, verrà eseguito solo code.txt.

In realtà, prima del programma principale, viene fatta la ricerca di un eventuale file di setup che può chiamarsi, in ordine: settings.txt, settings.py, boot.py, boot.txt

Normalmente non viene mai utilizzato un file di setup e lo si usa in casi particolari per riconfigurare la funzionalità dell’USB; se ad esempio vogliamo realizzare un logger che salvi i dati in un file di testo e questo file di testo deve essere visibile all’utente quando collega la board al PC (cioè salvata sull’unità di storage generata dal Pico), in questo caso si mette, appunto, questo file di setup che fa in modo da dare all’interprete del CircuitPython i permessi in scrittura sulla memoria di massa. Maggiori informazioni sulla funzionalità del setup le trovate nella guida di Adafruit. Il Setup, inoltre, viene eseguito una sola volta (quando diamo tensione alla board) e non viene rieseguito dopo un soft-reset.

Dal momento che durante l’esecuzione del setup la seriale non è disponibile perchè la porta USB viene riconfigurata, eventuali messaggi vengono scritti in quel file di testo che vedete nella memoria di massa: boot_out.txt

Adafruit raccomanda di chiamare il programma principale sempre code.py

Installazione librerie aggiuntive

Il pacchetto completo con tutte le librerie da utilizzare con il CircuitPython va scaricato da questa pagina. Nel momento in cui scrivo ci sono 4 diversi downloads:

  • Bundle version 6.x : scaricate questo pacchetto se state utilizzando la versione 6.qualcosa del CircuitPython. Al momento la versione 6.3 di CircuitPython è quella stabile.
  • Bundle version 7.x : scaricate questo pacchetto se state utilizzando la versione 7.qualcosa del CircuitPython. Al momento in cui scrivo l’articolo, la versione 7 di CircuitPython è alpha (non stabile)
  • Bundle version Py: mentre i due downloads precedenti contengono le versioni delle librerie precompilate (ovvero in formato .mpy, che occupa meno spazio), qui ci sono le versioni non compilate (formato .py), quindi leggibili dagli umani, funzionanti con qualsiasi versione di CircuitPython, ma che occupano più spazio nella memoria di storage del Pico.
  • Bundle Examples: non sono librerie, bensì esempi di utilizzo delle stesse, sono fatti per funzionare con l’ultima versione delle librerie, quindi è possibile che tali esempi non funzionino con qualsiasi versione di CircuitPython, né tantomeno sulla scheda che stiamo usando dato che il CircuitPython è fatto per girare anche su altri dispositivi diversi dal Pico. Non c’è bisogno di scaricare questo file perchè gli stessi, identici, esempi sono già inclusi nei files zip del bundle delle librerie e comunque ci serviranno a ben poco.

Quindi, ricapitolando: se sul Pico abbiamo installato l’UF2 di CircuitPython versione 6.3, allora scaricheremo le librerie Bundle Version 6.x. 

Oppure possiamo scaricare la versione Py che va bene con tutti gli interpreti ma le librerie occupano un sacco di spazio, non tengo in considerazione di questa opzione in quello che scrivo successivamente.

Quando andiamo ad estrarre il file .zip delle librerie, ci ritroveremo 3 cartelle: examples, lib e requirements. Nella cartella lib ci sono i files di libreria (dai!). Le librerie possono presentarsi in cartelle (perchè sono costituite da più files) oppure come singoli files .mpy. Se la libreria è costituita da una cartella con più files, allora andrà copiata l’intera cartella all’interno della cartella lib presente sul Pico. Se invece la libreria è costituita da un solo file .mpy, allora andrà copiato solo il file .mpy nella cartella lib del Pico: semplice no?

Può capitare, però, che alcune librerie non funzionino e impallino il Pico: questo perchè, probabilmente, richiedono ulteriori librerie per poter funzionare. In questo caso ci torna utile la cartella requirements: in tale cartella ci sono tante cartelle con il nome delle librerie che necessitano di ulteriori requisiti per funzionare. All’interno di ogni cartella di requirements c’è un semplice file di testo requirements.txt in cui c’è scritto di quali altre librerie abbiamo bisogno di copiare per poter utilizzare la libreria che ha il nome della cartella.

Facciamo un esempio! Vogliamo utilizzare la libreria per i display OLED basati sul controller SSD1306. Spulciando nella cartella lib troviamo una cartella che si chiama adafruit_ssd1306 : perfetto! E’ questa! Copiamo tale cartella nella cartella lib presente sul Pico. Se andremo già ad utilizzarla, noteremo che non succede nulla: il display non funziona (e lo dico perchè l’ho fatto io per primo, sia chiaro!), questo perchè non abbiamo fatto i conti con i prerequisiti!

Adesso andiamo quindi a vedere se tale libreria ha bisogno di altro per poter funzionare: andiamo nella cartella requirements. Vediamo che c’è una cartella che si chiama adafruit_ssd1306: apriamola. Dentro c’è il file requirements.txt, apriamolo con un blocco note e troviamo questo contenuto:

Questo vuol dire che, per utilizzare la libreria adafruit_ssd1306 oltre a copiare sul Pico (nella cartella lib) il file di libreria adafruit_ssd1306.mpy dovremo copiare anche le librerie:

  • Adafruit-Blinka
  • adafruit-circuitpython-busdevice
  • adafruit-circuitpython-framebuf

Andando a cercare queste 3 librerie nella cartella lib ci accorgiamo che:

  • La prima (Adafruit-Blinka) non esiste
  • Non c’è nessuna cartella/singolo file .mpy che si chiama adafruit-circuitpython-busdevice ma c’è una cartella  che si chiama adafruit-busdevice (ed è questa! il nome circuitpython è omesso)
  • Non c’è nessuna cartella/singolo file .mpy che si chiama adafruit-circuitpython-framebuf ma c’è un file singolo che si chiama adafruit_framebuf.mpy (ed è questo!)

La prima libreria, Adafruit-Blinka, in realtà non c’è perchè non serve: Blinka è difatti una libreria che serve ad utilizzare le API di CircuitPython su dispositivi che utilizzano una diversa implementazione del Python, come MicroPython e CPython. Essendo queste librerie che abbiamo scaricato proprio per CircuitPython, non c’era bisogno di tale libreria ma è rimasta nei files di testo dato che possiamo utilizzare queste librerie anche su altri dispositivi che non usano il CircuitPython ma una delle altre due implementazioni del Python.

Riguardo alle altre due questioni, invece, (il fatto che le cartella non contengano la dicitura circuitpython nel nome) è spiegato nel design guide del CircuitPython.

Ricapitolando: l’importante è che copiate l’intera cartella (se la libreria è in una cartella) o il singolo file .mpy (se cercate una libreria e non trovate la cartella, scorrete più in basso per vedere se c’è invece il file singolo) e poi andare a vedere nella cartella requirements se bisogna copiare anche altro per farla funzionare: se nel nome della libreria è presente la parola circuitpython stiamo sicuri che facendo la ricerca nella cartella delle librerie, tale parola dobbiamo ometterla. Se poi è scritta una libreria che in realtà non c’è (come Blinka in questo caso) allora non fa niente: se non c’è vuol dire che non serve.

Infine la cartella examples: ci sono, chiaramente, degli esempi di utilizzo delle librerie, ma in realtà molti di tali esempi non possono essere utilizzati sul Pico in quanto si tratta di esempi fatti per essere interpretati dal CircuitPython che gira, ad esempio, su Raspberry Pi oppure per altre piattaforme: li possiamo leggere per avere un’idea ma non è detto che funzionino se copiati tal quale.

Scrivere il codice

Per la scrittura e l’upload del codice in CircuitPython, Adafruit ha preparato un capitolo apposta nella guida del MicroPython. Con il MicroPython dovevamo utilizzare Thonny che supporta anche l’upload sulla scheda dato che con questo interprete la board non viene riconosciuta come unità di storage. Con CircuitPython la questione è più semplice perchè è possibile scrivere del codice e poi uploadarlo nello storage di massa ma c’è un MA.

L’interprete del CircuitPython rileva automaticamente quando un file è cambiato e lo riesegue in automatico appena finita la scrittura: questo rende il caricamento del codice molto veloce perchè non appena viene salvato, riparte aggiornato in automatico. Il problema nasce nel momento in cui andiamo a scollegare la scheda: alcuni editor ci mettono un po’ di tempo per salvare anche se non sembra (sembra che la scrittura sia completata, invece la memoria di massa sta ancora lavorando), per cui può accadere che scolleghiamo la scheda prima che il file sia completamente salvato, corrompendolo. Per questo motivo Adafruit consiglia l’utilizzo dell’editor Mu. 

Mu, tra le altre cose, salva il file in maniera sicura. Ad ogni modo lo fanno anche Thonny, Visual Studio Code e altri. Mu, in aggiunta, fornisce anche dei suggerimenti di scrittura del codice (in realtà per alcune cose lo trovo un po’ odioso perchè segnala ogni minima cosa, anche non essenziale, ma magari fa bene perchè forza a scrivere il codice in maniera pulita) e supporta REPL per l’output su seriale.

In un prossimo articolo vedremo qualche esempio di scrittura del codice.

Links

Acquisto prodotti

Informazioni varie e downloads

Risorse Maker Pi Pico

Risorse Maker Pi RP2040

Se questo articolo ti è piaciuto, condividilo su un social:
      
Se l'articolo ti è piaciuto o ti è stato utile, potresti dedicare un minuto a leggere questa pagina, dove ho elencato alcune cose che potrebbero farmi contento? Grazie :)