Nel primo post pubblicato sull’uso di Raspberry Pi Pico, avevo concluso il tutorial mostrando come controllare l’accensione del LED sulla scheda, quello connesso alla pin 25. Il passo successivo, molto semplice, in quanto riprende i medesimi passaggi dell’ultimo esempio mostrato, sarà quello di controllare un LED esterno alla scheda.
Ovviamente sappiamo già che in serie al LED dovrà essere inserita una resistenza per controllare la corrente che fluisce nel LED (per approfondimenti consultare il link). Poiché in questo caso la tensione di alimentazione del LED sarà quella disponibile sulla scheda, 3,3 Volt, considerando un LED rosso, con una corrente di funzionamento di 15 mA ed una tensione di soglia di 1,8V, usando la legge do Ohm il valore della resistenza serie dovrà essere di 100 Ohm. Nel caso non abbiate questo valore potrete utilizzare anche i classici valori, 220 Ohm o 330 Ohm, che trovate in un qualsiasi kit di sperimentazione, valori più grandi di resistenza ovviamente faranno emettere a parità di tensione, una luminosità inferiore.
Colleghiamo un reoforo del resistore al pin digitale 15 (GPIO 15), il restante reoforo all’anodo del LED ed il catodo del LED al GND. Di seguito le immagini del Pin Out del PiPico e schema di collegamento:
Prendendo a riferimento il programma in MicroPython del precedente tutorial, andiamo a variare alcune linee di codice. Bisognerà modificare solamente il numero del pin digitale utilizzato:
# Prof. Maffucci Michele
# Blink LED connesso al pin 15
# 10.09.2021
# libreria che permette di utilizzare MicroPython con il RaspyMicro
import machine
# per la gestione del tempo
import utime
#pin 15 dichiarato come OUTPUT
ledEsterno = machine.Pin(15, machine.Pin.OUT)
# loop infinito, while sempre vero, che scrive, ad intervalli di 1 secondo
# sul pin 15 il valore 1 e 0
while True:
ledEsterno.value(1) # imposta il livello logico 1 sul pin 15
utime.sleep(1) # lo stato logico 1 viene mantenuto per 1 secondo
ledEsterno.value(0) # imposta il livello logico 0 sul pin 15
utime.sleep(1) # lo stato logico 0 viene mantenuto per 1 secondo
Per la realizzazione della lezione sull’uso del PIR HC-SR501 pubblicato alcuni giorni fa, per lavorare agevolmente con il sensore ho creato un semplice supporto che poi ho stampato in più copie per le sperimentazioni di laboratorio di Sistemi a scuola. Non appena ho pubblicato il post ho ricevuto alcune mail da parte di colleghi e studenti che mi hanno chiesto i sorgenti grafici del supporto.
Potete prelevare i file per la stampa 3D direttamente dalla mia pagina su Thingiverse: PIR HC-SR501 support
In questa lezione vedremo come collegare e controllare i servomotori a rotazione continua di SumoBot.
Fate riferimento allo schema di collegamento che segue, in cui i servomotori vengono connessi ai pin 4 e 5 della Sensor Shield per Arduino Uno Nano V3, come si nota a fianco di ogni pin è disponibile l’alimentazione, infatti troviamo sempre il positivo, indicato con la lettera V e il GND indicato con la lettera G. Come ribadito nella lezione 1 utilizziamo una Sensor Shield perchè permette rapidamente di realizzare tutti i collegamenti senza la necessità i dover ricorrere ad una breadboard oppure alla saldatura dei cavi.
Per questa lezione vengono indicati solo i collegamenti ai motori, non verranno collegati ne il sensore ad ultrasuoni e ne i sensori ad infrarossi.
Per quanto riguarda l’utilizzo dei servomotori a rotazione continua fare riferimento alla slide: Alfabeto di Arduino – Lezione 6, ma per completezza riporto di seguito la spiegazione adattandola all’utilizzo con SumoBot.
Il servomotore è costituito in genere da tre cavi connessi ad un connettore femmina con passo standard tra i fori di 2,54 mm quindi facilmente utilizzabile con qualsiasi strip che ne permette il collegamento ad esempio su una breadboard oppure ai pin maschio della Sensor Shield che utilizziamo per SumoBot.
I fili di connessione possono assumere colori diversi in funzione della marca del servo.
Pinout del servomotore
Filo ROSSO: +V
Filo NERO o MARRONE: GND
Filo BIANCO o ARANCIO o BIANCO o BLU: Segnale
Nel servomotori adottati per questa esperienza i fili di connessione sono:
Filo ROSSO: +V
Filo MARRONE: GND
Filo ARANCIO: Segnale
Collegamenti
Guardando SumoBot frontalmente, collegheremo il motore di destra al pin 4 e il motore di sinistra al pin 5.
Principio di funzionamento del servomotore a rotazione continua
Notoriamente i servomotori possono effettuare una rotazione che oscilla tipicamente da 0 a 180, esistono inoltre modelli che consentono una rotazione inferiore tra 0 e 120 gradi, questi tipi di servomotori possono essere modificati facendo in modo che possano effettuare una rotazione continua, ovvero tra 0 e 360 gradi, ma in commercio sono disponibili servomotori di diverse dimensioni che funzionano in questa modalità. Nel kit utilizzato per la realizzazione di SumoBot utilizziamo due servomotori FS90R.
Sul servomotore a rotazione continua possiamo controllare da programma il senso di rotazione e in modo non molto preciso anche la velocità.
Il funzionamento di un servomotore a rotazione continua è simile a quella di un motore in corrente continua con la differenza che non necessitano di appositi shield per poter funzionare.
Rispetto ad altri tipi di motori in CC offrono scelte limitate per il controllo della velocità e limitazioni di alimentazione.
L’alimentazione potrà avvenire direttamente Attraverso Arduino o mediante alimentazione esterna. L’alimentazione dei motori di SumoBot avverrà direttamente dalla scheda Arduino.
Caratteristiche tecniche
Velocità di funzionamento a 4,8V: 110RPM
Velocità di funzionamento a 6V: 130RPM
Coppia di stallo a 4,8V: 1.3kg.cm/18.09oz.in
Coppia di stallo a 6V: 1.5kg.cm/20.86oz.in
Tensione operativa: 4.8-6V
Sistema di controllo: Analogico
Angolo di rotazione: 360 gradi
Impulso richiesto: 900-2100us
Materiale ingranaggi: Plastica
Dimensioni: 2,32×1,25×2,2 cm
Peso: 9g
Programmazione
/*
* Prof. Maffucci Michele
* SumoRobot
* Data: 26.01.2021
*
* Sketch 01: rotazione oraria e antioraria continua
*
* Note:
* Per l'orientamento del robot
* guardare SumoBot anteriormente
*
* 180: max velocità in senso antiorario
* 90 : servomotori fermi
* 0 : max velocità in senso orario
*
*/
// inclusione della libreria servo.h per il controllo dei servomotori
#include <Servo.h>
// Creazione oggetti servo
Servo motoreDX; // Inizializzazione del servomotore destro
Servo motoreSX; // Inizializzazione del servomotore sinistro
byte pinDx = 4; // Inizializza del pin 4 a cui è connesso il pin segnale del servo destro
byte pinSx = 5; // Inizializza del pin 5 a cui è connesso il pin segnale del servo sinistro
int durata = 250; // Durata movimento (orario/antiorario)
int ferma = 3000; // Durata dello stop
void setup() {
// attach() consente di definire a quale pin viene connesso il servomotore
// e lo collega all'oggetto che gestisce il servomotore
motoreDX.attach(pinDx); // pinDx collegato al motore destro
motoreSX.attach(pinSx); // pinSxcollega to al motore sinistro
}
void loop() {
orarioRobot(); // Rotazione in senso orario del robot
stopRobot(); // Stop rotazione per un tempo fissato (vedere variabile ferma)
antiorarioRobot(); // Rotazione in senso antiorario del robot
stopRobot(); // Stop rotazione per un tempo fissato (vedere variabile ferma)
}
// rotazione del robot in senso antiorario
void antiorarioRobot(void) {
motoreDX.write(150); // Rotazione oraria del motore DX
motoreSX.write(150); // Rotazione antioraria del motore SX
delay(durata); // durata: durata della rotazione
}
// rotazione del robot in senso orario
void orarioRobot(void) {
motoreDX.write(30); // Rotazione antioraria del motore DX
motoreSX.write(30); // Rotazione oraria del motore SX
delay(durata); // durata: durata della rotazione
}
// stop del robot
void stopRobot(void) {
motoreDX.write(90); // Ferma il motore DX
motoreSX.write(90); // Ferma il motore SX
delay(ferma); // Durata dello stop
}
Per quanto riguarda il controllo dei servomotori seguire la spiegazione inserita come commento all’interno del codice, ricordo comunque che per controllare i servomotori sono necessarie 4 operazioni:
includere la libreria Servo.h
creazione dell’oggetto Servo. motoreDx e motoreSx saranno i due oggetti su cui opererete
assegnare un nome al pin di controllo del servomotore (filo arancione nello schema)
indicare nel setup il metodo attach() che permette di legare gli oggetti motoreDx e motoreSx ai pin su Arduino nell’esempio 4 e 5 a cui abbiamo assegnato i nomi pinDx e pinSx.
All’interno del codice utilizziamo il metodo write() che per i servomotori a rotazione continua permette il passaggio, all’oggetto motoreDx e motoreSx, la direzione e la velocità di rotazione del motore:
passando il valore 0 gradi al metodo write() il servo ruota alla massima velocità in una direzione.
passando il valore 90 gradi al metodo write() poniamo il servo in stop (posizione “neutra”)
passando il valore 180 gradi al metodo write() il servo di ruotare in senso opposto alla massima velocità.
Nel codice che segue SumoBot ripeterà continuamente una rotazione oraria di 250 millisecondi, si fermerà per 3 secondi e riprenderà la rotazione in senso antiorario per 250 millisecondi.
Per effettuare questa operazione vengono definite 3 funzioni:
orarioRobot()
stopRobot()
antiorarioRobot()
Nel codice si può notare che nella funzione antiorarioRobot() viene passato al metodo write() non il valore 180 che farebbe ruotare il robot alla massima velocità, ma un valore inferiore, nel nostro caso 150, ciò ridurrà la velocità di rotazione.
In modo analogo accade per la funzione orarioRobot() in cui invece di passare il valore 0 alla metodo write(), che lo farebbe ruotare alla massima velocità in senso orario, passiamo un valore maggiore, 30, che lo farà ruotare ad una velocità inferiore.
La fermata del robot avviene utilizzando la funzione stopRobot() in cui viene passato il valore 90 al metodo write(), ciò fermerà i motori.
Si noti che i motori potranno ruoteranno in un senso o in un altro, oppure potranno essere fermati non solo invocando il metodo write, ma bisognerà sempre inserire un delay() in cui viene specificato per quanto tempo il metodo deve agire.
Esercizio 01
Far compiere a SumoBot rotazioni continue di 90 gradi in senso orario inserendo un intervallo di 3 secondi ad ogni quarto di giro
Esercizio 02
Far compiere a SumoBot una rotazione continua di 360° con intervalli di 3 secondi ad ogni quarto di giro, raggiunti i 360° far cambiare il senso di rotazione ripetendo le fermate di 3 secondi ad ogni quarto di giro.
Esercizio 03
Individuare quanto tempo necessita per far effettuare una rotazione di 45° in senso orario a SumoBot e realizzare un programma che permetta di fare le seguenti operazioni:
Questa mattina, durante la realizzazione e l’analisi dei problemi per il progetto di PCTO: “misura di sedentarietà delle persone sedute alla scrivania” che stanno realizzando i miei studenti di 3′ Elettronica, è nata l’esigenza di associare un doppio controllo per la valutazione della presenza della persona seduta alla scrivania, un controllo effettuato con PIR HC-SR501 ed un sensore di forza resistivo (FSR) inserito all’interno del cuscino della seduta.
Per evitare l’acquisto di un sensore di forza resistivo e non pesare sulle finanze dei ragazzi le modalità sono tre:
richiesta alla scuola
compra il Prof.
farlo costruire ai ragazzi
l’acquisto da parte della scuola o mia non è un problema, ma la terza soluzione è quella che in questo momento prediligo, perché può essere realizzata in 5 minuti, credo che possa gratificare di più lo studente Maker in erba 🙂 , inoltre ritengo importante che gli allievi assumano la capacità di costruire il sensore perché ne dovranno ottimizzare l’uso, scontrandosi inevitabilmente con una serie di variabili fisiche che dovranno gestire.
Ma come si costruisce il sensore?
E’ indispensabile piccolo tubo cilindrico non trasparente, preferibilmente nero che possa essere compresso e al termine della compressioni ritorni abbastanza velocemente nella sua posizione di riposo. Possiamo ricavare il tubo sguainando un cavo elettrico o cavo di rete, oppure come ho fatto in questo tutorial, prendendo una guaina termorestingente.
Inserire un diodo LED ad un’estremità del cilindro e dalla parte opposta inserire un LDR.
Collegare il sistema nella solita modalità, inserendo in serie al LED un resistore da 220 Ohm e creando un partitore di tensione tra l’LDR e un resistore da 10KOhm, così come indicato nel circuito indicato di seguito.
Come test di funzionamento utilizzare il semplice sketch che trovate di seguito, nei commenti la spiegazione di tutte le parti del codice.
Aprite la Serial Monitor e premete e rilasciate il tubo
/*
* Prof. Michele Maffucci
* Data 01.03.2021
*
* Oggetto: sensore di seduta a pressione
*
*/
// variabile in cui verrà memorizzato il valore presente sul pin A0
const int misura = A0;
// valore restituito dall'analogRead
int val = 0;
// pin a cui è connesso il LED del sensore di seduta
int pinLed = 2;
// LED che segnala la seduta della persona
int pinLedAlert = 13;
void setup() {
// Inizializzazione della Serial Monitor
Serial.begin(9600);
// ledPin è il pin a cui è connesso il LED del sensore di seduta
pinMode(pinLed, OUTPUT);
// pinLedAlert è il pin a cui è connesso il LED che segnala la seduta della persona
pinMode(pinLedAlert, OUTPUT);
// Attivazione del LED del sensore di seduta
digitalWrite(pinLed, HIGH);
// Messaggio di avvio
Serial.println("Sistema di rilevazione seduta");
Serial.println("-----------------------------");
Serial.println("");
delay(1000);
}
void loop() {
// analogRead leggerà il valore su A0 restituendo un valore tra 0 e 1023
val = analogRead(misura);
// il valore di controllo nell'if deve essere sperimentato in funzione
// delle necessità costruttive (ad es. la lunghezza del tubo)
// se vero la persona è seduta
if (val >= 100) {
digitalWrite(pinLedAlert, HIGH); // accensione del LED di avviso
Serial.println("Persona NON seduta alla scrivania"); // segnalazione di assenza persona
Serial.print("Valore letto dal sensore = "); // Stringa di stampa
Serial.println(val); // Valore restituito dall'AnalogRead
Serial.println(""); // Stampa linea vuota di separazione
delay(1000); // Intervallo di 1 secondo tra ogni stampa
}
else
{
digitalWrite(pinLedAlert, LOW); // spegnimento del LED di avviso
Serial.println("Persona seduta alla scrivania"); // segnalazione di presenza persona
Serial.print("Valore letto dal sensore = "); // Stringa di stampa
Serial.println(val); // Valore restituito dall'AnalogRead
Serial.println(""); // Stampa linea vuota di separazione
delay(1000); // Intervallo di 1 secondo tra ogni stampa
}
}
Il risultato sulla Serial Monitor è il seguente
Il valore di soglia scelto deve essere ricavato sperimentalmente in funzione della lunghezza e della trasparenza del tubo.
Raspberry Pi Pico è una nuovissima scheda di prototipazione elettronica estremamente potente ed economica che monta il microcontrollore RP2040 costituito da un Cortex-M0+. La scheda è prodotta da Raspberry Pi ed ha un costo estremamente contenuto, circa € 4,5.
La scheda ha una dimensione simile a quella di un Arduino Nano, però rispetto alle schede della famiglia Arduino che montano microcontrollori ATmega, possiede una potenza di calcolo e di memoria superiore. Inoltre è possibile programmarla in MicroPython, C e C++.
La scheda è stata messa in vendita qualche settimana fa e non appena commercializzata ho deciso di acquistarne 10 schede, ulteriori 10 schede mi arriveranno tra qualche giorno ciò mi permetterà di gestire un’intera classe di studenti e le prime sperimentazioni le effettuerò con i miei studenti di 5′ Elettronica e Automazione a cui assegnerò il compito di sviluppare le esercitazioni che poi utilizzerò nel prossimo anno scolastico con i miei studenti di 3′ del percorso elettronica e automazione.
Come prima attività in DaD ho chiesto ai miei allievi di realizzare in autonomia un documento di presentazione del prodotto e una tabella di confronto con le schede Arduino che montano microcontrollori ATmega tutto ciò mi farà risparmiare tempo e ci permetterà di concentraci sull’attività pratica in laboratorio.
Con questo post ne voglio presentare le caratteristiche tecniche e la modalità di installazione del firmware ed un esempio di programmazione in MicroPython. Sul sito di riferimento potete trovare tutta la documentazione necessaria per utilizzare la scheda.
Pico viene venduto senza piedini di collegamento, quindi dovrete acquistarli e procedere poi voi a sedarli sulla scheda, quindi armatevi di tanta pazienza ed utilizzando una breadboard per fissare i pin, procedete con la saldatura.
L’RP2040 è il primo microcontrollore di Raspberry Pi. I due core del processore Cortex-M0+ del Pico funzionano a 48 MHz, anche se questo può essere modificato nel software fino a 133 MHz.
La RAM del microcontrollore è incorporata nello stesso chip dei core del processore, è costituita da sei banchi di memoria per un totale di 264kB (264.000 byte) di RAM statica (SRAM). La RAM viene utilizzata per memorizzare i vostri programmi e i dati di cui hanno bisogno i programmi.
L’RP2040 include 30 pin GPIO (general-purpose input / output) multifunzione, 26 dei quali sono collegati a connettori pin fisici sul vostro Pico e uno dei quali è collegato a un LED integrato sulla scheda. Tre di questi pin GPIO sono collegati a un convertitore analogico-digitale (ADC), mentre un altro canale ADC è collegato a un sensore di temperatura su chip.
L’RP2040 include due UART (ricevitore-trasmettitore asincrono universale), due SPI (Serial Periferal Interface) e due bus I2C (Inter-Integrated Circuit) per i collegamenti a dispositivi hardware esterni come sensori, display, convertitori digitale-analogico (DAC) e molto altro. Il microcontrollore include anche un ingresso/uscita programmabile (PIO), che consente al programmatore di definire nuove funzioni hardware e bus nel software.
Il Pico include un connettore micro USB, che permette un collegamento seriale UART-over-USB al microcontrollore RP2040 per la programmazione e l’interazione e che alimenta il chip. Tenendo premuto il pulsante BOOTSEL quando si collega il cavo, il microcontrollore passerà alla modalità “Dispositivo di archiviazione di massa USB”, consentendo di caricare il nuovo firmware.
L’RP2040 include anche un on-chip clock e timer, che permette di tenere traccia in modo preciso dell’ora e della data. Il clock può memorizzare l’anno, il mese, il giorno, il giorno della settimana, l’ora, i minuti e i secondi e tiene automaticamente traccia del tempo trascorso finché viene fornita l’alimentazione alla scheda. RP2040 include il single-wire debug (SWD) un debug hardware a tre fili nella parte inferiore del tuo Pico.
Pinout del Raspberry Pi Pico
Caratteristiche tecniche
CPU: 32-bit dual-core ARM Cortex-M0+ at 48MHz, configurabile fino a 133MHz
RAM: SRAM da 264kB disposi in 6 banchi indipendenti configurabili
Memoria: flash RAM esterna da 2MB
GPIO: 26 pins
ADC: 3 × 12-bit ADC pin
PWM: 16
Clock: Orologio e timer accurati su chip con anno, mese, giorno, giorno della settimana, ora, secondi e calcolo automatico dell’anno bisestile
Sensori: Sensore di temperatura On-chip connesso connesso ad un ADC 12-bit
Alimentazione: 5 V via micro USB, 3.3 V via 3V3 pin, o 2–5V via VSYS pin
Installare MicroPython
Dopo che avete effettuato le saldature dei pin abbiamo bisogno di installare MicroPython sulla scheda. Colleghiamo un cavo micro USB alla porta micro USB del vostro Pico.
Per installare MicroPython sul vostro Pico dovrete scaricarlo da Internet. Questa operazione è da fare una sola volta, dopo averlo installato rimarrà sul vostro Pico a meno che voi non decidiate di sostituirlo con qualcos’altro.
Mantenete premuto “BOOTSEL” nella parte superiore del tuo Pico, vicino al connettore USB, quindi, tenendolo ancora premuto, collega l’altra estremità del cavo micro USB a una delle porte USB del vostro computer Raspberry Pi o altro computer. Contate tre secondi, dopo di che rilasciate il pulsante “BOOTSEL”. Dovreste vedere il vostro Pico apparire come un’unità rimovibile, come se avessimo collegato un’unità flash USB o un disco rigido esterno. Sul vostro computer verrà aperta una finestra per aprire l’unità (la scheda) che avete connesso.
Nella finestra del vostro File Manager, vedrete due file sul Pico: INDEX.HTM e INFO_UF2.TXT. Il file INFO_UF2.TXT contiene informazioni sul Pico tra cui la versione del bootloader attualmente in esecuzione sul Pico.
Il file, INDEX.HTM, contiene tutte le informazioni utili per usare il Pico, fate doppio clic, sarete reindirizzati sulla pagina di benvenuto da cui reperire tutte le informazioni che servono per iniziare. Fate clic sulle schede scorrete la pagina per accedere alle guide, ai progetti e alla raccolta di libri: una libreria di documentazione tecnica dettagliata che copre tutto, dal funzionamento interno del microcontrollore RP2040 il cuore della vostra scheda, alla programmazione in Python e C / C ++.
Leggete tutte le informazioni sulla pagina, andate in “Getting started with MicroPython” e fate clic sul pulsante “Scarica file UF2” per scaricare il firmware MicroPython, che è un piccolo file che contiene MicroPython per il vostro Pico. Il download dal sito di riferimento richiede pochissimi secondi.
Una volta scaricato, andate nella vostra cartella Download cercate il file “micropython” seguito da una data e dall’estensione “uf2”. Fare clic e tenere premuto il pulsante del mouse sul file UF2, quindi trascinatelo sull’unità di archiviazione rimovibile di Pico (quindi all’interno del Pico). Posizionalo sulla finestra e rilascia il pulsante del mouse per rilasciare il file sul vostro Pico.
Dopo qualche secondo il vostro Pico scomparirà dal vostro File Manager e potreste anche vedere un messaggio del vostro sistema operativo che vi dice che un’unità è stata rimossa senza essere stata espulsa: non preoccupatevi, non è successo nulla di grave, ciò accade perchè quando avete trascinato il file del firmware MicroPython sul Pico, avete detto di eseguire il flashing del firmware nella memoria interna di Pico. Per fare il flashing il Pico esce dalla modalità speciale in cui lo avete inserito con il pulsante “BOOTSEL” (modalità periferica USB), vedrete lampeggiare il LED sulla scheda, ciò indica che Pico ora esegue MicroPython.
Bene! Ora siete pronti per iniziare a programmare in MicroPython su Raspberry Pi Pico! 🙂
Installiamo l’IDE Thonny per programmare in MicroPython.
Scarichiamo ora l’IDE di programmazione Thonny, vedremo in una lezione successiva come utilizzare Visual Studio Code.
Andate sul sito https://thonny.org e scaricate la versione per il vostro sistema operativo
Doppio click sull’applicazione, si aprirà la seguente finestra:
Configuriamo ora l’IDE per poter programmare il Pico, dal menù > Strumenti > Opzioni… selezionare “Interprete”
Scegliere MicroPython (Raspberry Pi Pico)
Determiniamo ora la porta seriale di connessione a cui abbiamo collegato il Pico, possiamo effettuare questa operazione oppure manualmente selezionate quella identificata da una lunga serie di 0 che termina con 1
Dal menù Strumenti > Gestione plug-in… inserire nel campo di ricerca “machine”
Si avvierà l’installazione, al termine chiudete la finestra.
Vediamo ora come effettuare il blink del LED sulla scheda.
Scrivimi all’interno dell’area di programmazione il seguente codice, fate attenzione all’indentazione, come sapete in Python è importante.
Questa prima linea di codice è importantissima in quanto vi consentirà di lavorare con MicroPython sul Pico, importerà la libreria “machine” che contiene tutte le istruzioni necessarie che permettono per fare comunicare MicroPython con Pico ed altri dispositivi compatibili con MicroPython.
Senza questa linea di codice non sarete in grado di controllare nessuno dei pin GPIO di Pico e non potrete controllare il LED sulla scheda.
La seconda linea di codice
import utime
Importa la libreria di MicroPython: “utime”. Questa libreria gestisce tutto ciò che ha a che fare con il tempo, dalla misurazione all’inserimento di ritardi.
led_onboard = machine.Pin(25, machine.Pin.OUT)
Questa riga definisce un oggetto chiamato led_onboard, che è il nome che assegniamo noi per fare riferimento al LED sulla scheda, possiamo tecnicamente utilizzare qualsiasi nome, possibilmente meglio scegliere nomi che abbiamo attinenza con la funzionalità dell’oggetto in modo da rendere più semplice la lettura del programma.
Come si può notare la funzione machine.Pin() è costituita da due parametri: il pin a cui è connesso il LED, il 25, seguito dalla modalità con cui viene usato il pin, OUT. Per chi ha familiarità con la programmazione con Arduino noterà che l’azione è la medesima, cambia solo la sintassi.
Definiamo un loop infinito in cui andremo ad inserire le istruzioni che vogliamo vengano ripetute per sempre.
while True:
Analizziamo le istruzioni nel corpo del while
led_onboard.value(1)
Questa linea di codice imposta il pin ad HIGH però da sola non permetterà ancora l’accensione del LED, è necessario indicare per quanto tempo il LED starà ad HIGH con la riga di codice che segue manteniamo ad 1 (HIGH) il Led per 1 secondo
utime.sleep(1)
Allo stesso modo impostiamo a 0 (LOW) il il pin a cui è connesso il LED
led_onboard.value(0)
facciamo in modo che questo stato duri per 1 secondo:
utime.sleep(1)
Fare ora clic sull’icona play per eseguire lo script:
il LED sulla scheda inizierà a lampeggiare
Per fermare l’esecuzione dello script sulla scheda fare click su STOP
Nel caso in cui invece desiderate rendere l’esecuzione automatica non appena il Pico viene connesso ad una fonte di alimentazione, rinominate il file in main.py e salvatelo sulla scheda
