Archivi categoria: programmazione

Guida all’uso di millis() – Lezione 1

Credo che una delle problematiche più ostiche da gestire soprattutto per i neofiti è l’utilizzo degli intervalli di tempo in cui eseguire operazioni con Arduino, mi riferisco all’uso e all’abuso improprio del delay(). Infatti gli studenti scoprono che, sebbene la funzione delay() sia facile da usare, ha degli effetti collaterali importanti; il principale è che ferma l’esecuzione dello sketch Arduino fino a quando non è trascorso il periodo di delay. Quando ciò accade, di solito chi spiega indirizza lo studente sull’esempio di defaut sulla temporizzazione non bloccante che troviamo nell’IDE di Arduino: BlinkWithoutDelay.

Molto spesso però questo confonde ancora di più le idee perché in realtà non si vuole solo far lampeggiare un LED ma si vogliono eseguire più operazioni contemporaneamente, quindi è bene comprendere a fondo il principio di funzionamento del BlinkWithoutDelay prima di poterlo applicare alla propria situazione.

Ho pensato quindi di realizzare qualche post tematico sull’uso di millis(), prendendo spunto dalle spiegazioni che realizzo per gli studenti.

Per usare millis() per la temporizzazione è necessario registrare il momento in cui un’azione si è verificata (ad esempio accensione di un LED ritardata alla pressione di un pulsante) affinché possiate iniziare a contare il tempo trascorso da tale evento, dovrete quindi controllare ad intervalli regolari se il periodo richiesto è trascorso.
Se tale intervallo di tempo non è trascorso allora il vostro programma potrà fare altro fino al prossimo controllo.

Nei programmi che seguono userò i commenti all’interno dello sketch per spiegare l’utilizzo delle varie parti del programma.

Ma cos’è millis()?

La funzione millis() restituisce il numero di millisecondi trascorsi dall’avvio del programma corrente su una scheda Arduino. Questo valore è restituito come un numero di tipo unsigned long.

Come Funziona

  • Incremento Automatico: il conteggio inizia automaticamente quando il microcontrollore sulla scheda Arduino viene alimentato o resettato. Il conteggio continua ad aumentare fino a che la scheda rimane alimentata.
  • Overflow: poiché millis() utilizza una variabile di tipo unsigned long, che ha una dimensione di 32 bit su Arduino, il valore massimo che può raggiungere è 4,294,967,295, dopo aver raggiunto questo valore, si andrà in overflow (ovvero Arduino non è in grado di memorizzare un numero più grande) e il valore restituito da millis() ripartirà da zero. Questo avviene dopo circa 49 giorni e 17 ore dall’ultimo reset della scheda.

Utilizzi di millis()

Di seguito una lista non esaustiva di alcuni utilizzi della funzione millis():

  • Temporizzazione non bloccante: a differenza di delay(), che ferma l’esecuzione del programma per un periodo specificato, millis() può essere utilizzato per realizzare pause o attese senza bloccare altre operazioni. Questo è particolarmente utile in applicazioni multitasking dove altre attività devono continuare ad essere eseguite.
  • Debounce: viene spesso usata per implementare il debounce di pulsanti o switch, riducendo gli effetti dei rimbalzi meccanici che possono causare letture multiple per una singola pressione.
  • Esecuzione di azioni a intervalli regolari: può essere utilizzata per eseguire specifiche azioni a intervalli regolari, come leggere sensori, aggiornare display, o inviare dati.

Pratica di utilizzo

Per utilizzare millis() per la temporizzazione, il vostro sketch deve conoscere il valore attuale del tempo (valore restituito da millis()) e questa rilevazione può essere fatto quando volete, in più punti dello sketch ovviamente dovrebbe essere fatta quando serve, ma vediamo cosa vuol dire.

Tipicamente il valore di millis() conviene registrarlo in una variabile ad inizio loop() o all’interno del setup() in questo modo:

millisCorrente = millis();

Regola di utilizzo:

  1. La variabile millisCorrente deve essere stata precedentemente dichiarata.
  2. Deve essere di tipo unsigned long perché millis() restituisce un intero long senza segno.

Regole generali che valgono per tutti i programmi che realizzerete, lo scrivo perchè puntualmente durante le correzioni qualcuno dimentica questa due regolette:

  1. Il nome della variabile, così come accade per tutte le variabili dovrebbe essere autoesplicativa, quindi il suo nome deve dare informazioni: “a cosa serve”
  2. Inoltre è buona regola utilizzare la notazione Camel Case per gestire nomi di variabili composte da più parole, ciò vale anche per le funzioni.

Come spesso accade durante le attività di laboratorio, lascio come semplicissimo esercizio per lo studente il desumere i componenti utilizzati e connessioni dagli sketch di esempio, quindi fate riferimento a quanto indicato in ogni singolo programma, si tratterà semplicemente di connettere dei LED con in serie un resistore da 220 Ohm. Per quanto riguarda l’ultimo esempio fate riferimento al link indicato che rimanda ad un altro post su questo sito.

Siete ora pronti per seguire le spiegazioni successive.

Continua a leggere

Visualizzare i dati inviati da un micro:bit ad un computer via seriale con un emulatore di terminale

Durante le attività di sperimentazione del mio prossimo corso sui laboratori green mostrerò l’uso di RTC per la rilevazione automatica dei dati provenienti da sensori, sarà quindi necessario leggere i dati ricevuti dal micro:bit ed inviati al micro:bit attraverso un PC via seriale USB. Per leggere le informazioni che transitano sulla seriale è possibile usare qualsiasi emulatore di terminale. Seguendo il link: Outputing serial data from the micro:bit to a computer trovate la documentazione dell’help online di microbit.org che mostra l’utilizzo di alcuni emulatori terminali per i diversi sistemi operativi.

Una modalità estremamente semplice e che vi tornerà utile anche in altre occasioni, è quella che fa uso della Serial Monitor di Arduino, vediamo di seguito come fare questa operazione.

Configurazione

Passo 1
Qualche tempo fa avevo indicato come usare l’IDE di Arduino per programmare micro:bit, seguite la procedura indicata nel link

Passo 2
Impostare la scheda

Passo 3
Impostare la porta a cui è connesso il micro:bit

Passo 4
Aprire uno sketch vuoto e fare click sull’icona Monitor Seriale

Passo 5
Impostate la velocità di comunicazione a 115200 baud

Il risultato che vedete nell’immagine è quello che deriva dalla realizzazione di un programma scritto in Blocks con l’IDE grafico di micro:bit in cui viene inviato ogni minuto sulla seriale:

  • la data della misurazione
  • l’ora della misurazione
  • la temperatura rilevata dal sensore di temperatura del micro:bit e la temperatura rilevata dal sensore disposto sull’RTC DS3231.

Ovviamente questi dati potranno essere inviati ad altri dispositivi con modalità di trasmissione diverse, tutto questo sarà approfondito durante il corso.

Buon Making a tutti 🙂

Sperimentazioni didattiche: Pair Cooperative Learning

Fonte: Wikimedia

Come molti insegnati “di una certa età” 🙂 anche io mi trovo a ricoprire la funzione di docente tutor per colleghi neoassunti e con loro devo svolgere diverse attività: osservazione, insegnamento cooperativo nel condurre la lezione e molto altro.
Come proposta di attività di sperimentazione didattica mi sono inventato in questa settimana un metodo che nasce da un suggerimento del mio amico, compagno di studi e per anni compagno di lavoro, Paolo Sasso che durante una chiacchierata mi suggeriva di sperimentare a scuola una tecnica di organizzazione della produzione del software molto interessante che suo figlio sta utilizzando durante l’attività di “stage aziendale” remunerato che gli studenti delle università inglesi svolgono al 4′ anno di corso. Nel caso specifico si tratta di una progettazione di un software industriale sviluppato in team a distanza.

La tecnica utilizzata è quella del Pair programming, trovate indicazioni seguendo il link e da cui ho tratto per scrivere questo post. Si tratta di una tecnica di produzione del software agile condotta in coppia in cui due programmatori lavorano su una sola postazione.
I due programmatori, in modo periodico ed alternato assumono le funzioni di: conducente (driver) e navigatore (navigator).
Il conducente si occupa di scrivere il codice, mentre l’osservatore svolge il ruolo di supervisore e di revisione istantanea del codice.
Il conducente ha l’obiettivo di portare a termine una soluzione funzionante del problema, mentre il navigatore si occupa di segnalare errori o proporre alternative di soluzione al conducente e come indicato sopra i due programmatori cambiano spesso ruolo.

Come utilizzare questa metodologia durante lo sviluppo di un’attività di laboratorio a scuola?

Mi sono inventato una metodologia che ho chiamato: Pair Cooperative Learning che si basa sul Pair programming e a questo ho aggiunto un metodo per gestire i momenti in cui avviene lo scambio dei ruoli il tutto calato in una realtà didattica.
In realtà chiamarla forse metodologia è troppo, ma poiché mi diverte trovare strategie nuove di insegnamento mi piace elevarla al livello di metodologia 🙂

Ho sperimentato in questa settimana con la mia classe 4A Elettronica il metodo e ne ho perfezionato oggi, documentandone precisamente le fasi di azione in un mio documento personale. Condivido con voi il pensiero anche perché questa strategia sarà quella che mostrerò al collega neoassunto e che proporrò di sperimentare in alcune sue classi da solo ed insieme a me.

Per chi mi segue, sa che utilizzo da sempre la tecnica del Pomodoro per gestire il mio tempo di lavoro e in alcune occasioni anche il tempo di svolgimento delle esercitazioni che faccio svolgere in laboratorio agli studenti.

Lo sviluppo è quindi:

  • modalità di sviluppo: Pair programming;
  • modalità di gestione del tempo di lavoro: Tecnica del Pomodoro.

Ciò vuol dire che i ruoli si scambieranno ogni 25 minuti di attività in modalità Pair programming seguiti da 5 minuti di pausa vera in cui gli studenti devono riposare. Nei 25 minuti di lavoro in Pair programming non devono esserci distrazioni, quindi vietato chiedere: “Prof. posso andare a prendere un caffè?”, “Prof. posso andare al bagno?”, è vietato utilizzare smartphone e smartwatch, quindi bisogna allontanarli, non in tasca altrimenti si può venir distratti dalla vibrazione delle notifiche, ma riponendoli sulla cattedra o nello zaino personale.
Allo scadere dei 25 minuti ci saranno 5 minuti di pausa vera in cui riposarsi o andare al bagno.
Durante i 25 minuti non è possibile rivolgere domande al docente sulla svolgimento dell’attività, a meno che non si tratti di problematiche tecniche non conosciute dagli allievi. Dopo 4 pomodori (4 momenti lavorativi da 25 minuti) gli studenti sono obbligati a svolgere 15 minuti di pausa.

Per svolgere questa attività, adesso che sono in fase di sperimentazione, mi concentrerò su attività di laboratorio che possono essere iniziate e concluse in 2 o 3 ore continuative di lavoro.

Vantaggi rilevati:

  • concentrazione;
  • riduzione della distrazione;
  • capacità di suddivisione dei momenti produttivi da quelli di riposo;
  • imparare, a lungo termine, a valutare quanti “pomodori” sono necessari per svolgere una specifica attività;
  • percepire che si è protagonisti del proprio apprendimento;
  • percepire di aver risolto un problema;
  • cooperare con compagni di classe che solitamente non si sceglie per studiare e lavorare.

La formazione delle coppie di lavoro può avvenire in diverse modalità e sarà funzione sul livello di competenze raggiunto da ogni singolo allievo, pertanto potrà avvenire:

  • in modo casuale per ogni esercitazione e la casualità la si può ottenere con un programma facendo attenzione che in ogni esercitazione si formino sempre coppie diverse;
  • a scelta da parte del docente scegliendo in funzione delle competenze degli studenti.

Per velocità di sperimentazione questa settimana la scelta delle coppie di studenti è stata fatta da me ed un’altro collega.

Applicherò questa strategia venerdì prossimo nella mia 5B Automazione in cui gli studenti dovranno risolvere un problema di automazione mediante l’uso di PLC Siemens. L’attività, nei primi 25 minuti, prevederà un’analisi del sistema mediante lo sviluppo di un diagramma di flusso e nei successivi 25 minuti la produzione del codice in LADDER o FBD dell’automazione che dovrà essere poi simulata. La conclusione deve avvenire durante due ore di lezione.

Il metodo ovviamente è applicabile anche ad altri livelli scolastici, potrebbero essere ad esempio lo sviluppo di un’attività di Storytelling con Scratch 3 per allievi di scuola media o dei primi anni delle superiori, o ancora potrebbe essere un’attività non informatica in cui il processo può essere condotto in Pair Cooperative Learning.

Spero che questa mia sperimentazione possa essere utile anche ad altri colleghi e nel caso di vostre variazioni e migliorie vi chiedo la cortesia di comunicarmele in modo che a mia volta possa adottarle nelle mie classi.

Grazie Paolo per il suggerimento.

Buona didattica a tutti 🙂

Raspberry Pi Pico – come cancellare un file dalla memoria del microcontrollore

Come avrete notato durante le prime sperimentazioni con il PiPico, possiamo depositare all’interno della memoria del microcontrollore più programmi in MicroPython e decidere quali di questi mandare in esecuzione. Nel caso in cui si desideri rendere l’avvio automatico e continuo uno programma non appena il PiPico  viene connesso ad una fonte di alimentazione, è sufficiente rinominate il file in main.py.
Può accadere quindi che le nostre sperimentazioni ci portino a memorizzare più programmi all’interno della memoria del PiPico pertanto si potrebbe avere la necessità di dover cancellare o rinominare alcuni di questi.
In questo breve tutorial vedremo come cancellare un file usando i comandi che inseriremo nella shell di Thonny.

Come aprire un programma memorizzato nel PiPico

Per poter consultare la lista di file memorizzati all’interno del microcontrollore con l’IDE Thonny, fate clic su “Apri” (seconda icona)

Si aprirà un pannello che richiede la selezione dell’unità da aprire: sul computer o sul PiPico, selezionare il Raspberry Pi Pico

Ciò aprirà la finestra di seguito indicata da cui poter visionare la lista dei file e con cui potrete aprire uno dei file per poi modificarlo o eseguirlo.

Cancellare un file memorizzato nel PiPico

Posizionate il cursore nella prima riga della Shell e digitate il comando. Inseriremo una serie di comandi terminali in Python:

import os

in Python “import os” consente di importare i moduli necessari per interfacciarsi con il sistema operativo sottostante su cui Python è in esecuzione ed eseguire una serie di operazioni sui file, come ad esempio la cancellazione, lo spostamento dei file, rinominare file, creare directory e molto altro. Poichè con MicroPython non si ha nessun sistema operativo il modulo os fornisce tutte quelle funzioni relative alla gestione del semplice del file system e le informazioni relativo al sistema.

Continua a leggere

Dove prelevare tutte le versione del Firmware per il Raspberry Pi Pico e come installarlo

L’installazione del Firmware sul Raspberry Pi Pico è descritta nel primo post pubblicato, rispetto alla prima pubblicazione del mio post, le pagine della documentazione di Raspberry Pi Fundation sono state modificate, il clic sul file INDEX.HTM all’interno del vostro PiPico rimandava direttamente alla pagina di download, ora invece rimanda alla home page della documentazione. Per rendere più agevole il download, quindi, così come segnalato sul mio profilo Facebook, segnalo il link diretto alla pagina e alla sezione specifica di download.

Successivamente clic su: Download the MicroPython UF2 file.

Ciò che scaricherete è l’ultima versione (stable), ma nel caso in cui abbiate necessità di avere l’ultima versione, oppure desiderate sperimentare l’uso dell’ultima versione beta o ancora avere tutte le versioni passate del firmware, il sito di riferimento è https://micropython.org

recatevi nella sezione: Download

Selezionate: Raspberry Pi RP2040 microcontroller boards

Nella pagina troverete tutte le versioni, un clic sul link corrispondente per effettuare il download

L’installazione può avvenire tramite REPL, oppure premendo il pulsante sulla scheda BOOTSEL e procedere come descritto nel mio post.

L’installazione del Firmware può avvenire in una modalità ancora più comoda utilizzando anche l’editor Thonny che abbiamo iniziato a conoscere.

Connettete il PiPico al computer mantenendo premuto il pulsante BOOTSEL, dopo non più di 3 secondi rilasciate il pulsante, comparirà l’unità USB sul vostro computer. Avviate Thonny comparirà la seguente finestra:

Clic sul “Installa”

Al termine comparirà il messaggio “Done!”

Se fate clic su “Done!” si aprirà la finestra di stato che vi dirà su quale porta USB è connesso il vostro PiPico:

Un clic su “Chiudi” per iniziare a programmare.

Buon Making a tutti 🙂