Archivi tag: Python

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

Lascia una risposta

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→

Articoli correlati:

  1. Dove prelevare tutte le versione del Firmware per il Raspberry Pi Pico e come installarlo
  2. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 3
  3. Raspberry Pi Pico – Blink di un LED esterno

Raspberry Pi Pico – Blink di un LED esterno

Lascia una risposta

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

Buon coding a tutti 🙂

Articoli correlati:

  1. Raspberry Pi Pico – conosciamo la scheda ed installiamo MicroPython
  2. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 1
  3. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 2
  4. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 3
  5. Programmare Raspberry Pi Pico con l’IDE di Arduino

MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 3

Lascia una risposta

Disegnare immagini statiche è divertente, ma ancora più divertente è farle muovere e fare questo con MicroPython è molto semplice, è sufficiente indicare un elenco di immagini, in questa lezione vedremo come fare.

Per capire come animare una serie di immagini abbiamo necessità di utilizzare le liste.

Lista della spesa:

Uova
Prosciutto
Pomodori

Questo è il modo per rappresentare una lista in Python:

spesa = ["Uova", "Prosciutto", "Pomodori" ]

Abbiamo creato un elenco chiamato spesa   che contiene tre elementi. Python sa che è un elenco perché è racchiuso tra parentesi quadre ([  e ] ). Gli elementi nella lista sono separati da una virgola (, ) e in questo caso gli elementi sono tre stringhe di caratteri: “Uova”, “Prosciutto” e “Pomodori”. Sappiamo che sono stringhe di caratteri perché sono racchiusi tra virgolette “.

Nota

I numeri non hanno bisogno di essere inseriti all’interno delle doppie virgolette, in quanto rappresentano un valore (piuttosto che una stringa di caratteri).

Quindi 2  senza virgolette rappresenta il valore numerico 2 mentre 2 tra virgolette “2”  rappresenta il carattere/cifra che rappresenta il numero 2.

È possibile memorizzare elementi di diverso tipo all’interno della stessa lista:

lista_mista = [“ciao!”, 1.234, Image.HAPPY]

Notate che l’ultimo elemento è un’immagine!

E’ possibile dire a MicroPython di animare un elenco di immagini. Fortunatamente sono disponibili un paio di elenchi di immagini già integrate, si chiamano Image.ALL_CLOCKS  e Image.ALL_ARROWS :

from microbit import *

display.show(Image.ALL_CLOCKS, loop=True, delay=100)

Verrà visualizzata una lancetta che girerà in senso orario, l’intervallo di accensione dei tre LED è di 100 millisecondi.

Come abbiamo visto per la visualizzazione di una sola immagine usiamo display.show  per mostrarlo sul display del micro:bit. Quando diciamo a MicroPython di usare Image.ALL_CLOCKS  ci verranno mostrate in sequenza tutte le immagini della lista, inoltre nell’istruzione con il parametro loop=True  indichiamo che la lista delle immagini deve scorrere per sempre e con l’argomento delay=100  indichiamo che ogni immagine deve essere visualizzata per 100 millisecondi (1/10 di secondo).

  • Avete capito come animare la lista Image.ALL_ARROWS  ?
  • Come si evita il loop infinito?
    (suggerimento: l’opposto di True  è False  sebbene il valore predefinito per loop sia False )
  • Potete cambiare la velocità dell’animazione?

Vediamo come creare un’animazione di un’esplosione di luci, una sequenza che parte con l’accensione del LED centrale per espandersi verso il perimetro con differenti intensità luminose dei LED

from microbit import *

luce1 = Image("00000:"
"00000:"
"00900:"
"00000:"
"00000")

luce2 = Image("00000:"
"09990:"
"09590:"
"09990:"
"00000")

luce3 = Image("00000:"
"05550:"
"05350:"
"05550:"
"00000")

luce4 = Image("09590:"
"93339:"
"93039:"
"93339:"
"09590")

luce5 = Image("03330:"
"30003:"
"30003:"
"30003:"
"03330")

luce6 = Image("00000:"
"00000:"
"00000:"
"00000:"
"00000")

luci = [luce1, luce2, luce3, luce4, luce5, luce6]
display.show(luci, delay=200)

 

Questo è il modo con cui funziona il programma:

  • creiamo sei immagini luce  nello stesso modo descritto sopra.
  • Poi le inseriamo tutte in una lista chiamata luci .
  • Infine chiedo a display.show  di animare la lista con un ritardo di 200 millisecondi.
  • Poiché non abbiamo impostato loop=True  vedremo l’animazione una sola volta.

Proviamo ora a creare una sequenza che si ripete ciclicamente, in questo caso sarà sufficiente inserire il codice all’interno di un blocco while

from microbit import *

ritardo=100

luce1 = Image("00000:"
"00000:"
"00900:"
"00000:"
"00000")

luce2 = Image("00000:"
"09990:"
"09590:"
"09990:"
"00000")

luce3 = Image("00000:"
"05550:"
"05350:"
"05550:"
"00000")

luce4 = Image("09590:"
"93339:"
"93039:"
"93339:"
"09590")

luce5 = Image("03330:"
"30003:"
"30003:"
"30003:"
"03330")

luce6 = Image("00000:"
"00000:"
"00000:"
"00000:"
"00000")

luci = [luce1, luce2, luce3, luce4, luce5, luce6]

while True:
    display.show(luci, delay=ritardo)

Come si nota è stato inserito all’interno di un loop infinito: while True  l’istruzione display.show(luci, delay=ritardo) . Rispetto alla versione precedente è stata anche parametrizzato il valore del delay , inserito come parametro ritardo  all’inizio del codice, ciò permetterà di variare ad inizio programma la velocità con cui apparirà la sequenza delle sei immagini.

L’esempio riportato sopra ripeterà ad ogni ciclo la sequenza delle immagini da luce1  a luce6 , nel caso in cui si voglia dare un’effetto di ribalzo sarà sufficiente creare due collezioni luciA  e luciB  i cui la sequenza delle immagini è invertita:

from microbit import *

ritardo=100

luce1 = Image("00000:"
"00000:"
"00900:"
"00000:"
"00000")

luce2 = Image("00000:"
"09990:"
"09590:"
"09990:"
"00000")

luce3 = Image("00000:"
"05550:"
"05350:"
"05550:"
"00000")

luce4 = Image("09590:"
"93339:"
"93039:"
"93339:"
"09590")

luce5 = Image("03330:"
"30003:"
"30003:"
"30003:"
"03330")

luce6 = Image("00000:"
"00000:"
"00000:"
"00000:"
"00000")

luciA = [luce1, luce2, luce3, luce4, luce5, luce6]
luciB = [luce6, luce5, luce4, luce3, luce2, luce1]

while True:
    display.show(luciA, delay=ritardo)
    display.show(luciB, delay=ritardo)

Per avere una struttura compatta del codice, così come mostrato in precedenza, il codice può essere scritto in questo modo:

from microbit import *

ritardo=100

luce1 = Image("00000:00000:00900:00000:00000")
luce2 = Image("00000:09990:09590:09990:00000")
luce3 = Image("00000:05550:05350:05550:00000")
luce4 = Image("09590:93339:93039:93339:09590")
luce5 = Image("03330:30003:30003:30003:03330")
luce6 = Image("00000:00000:00000:00000:00000")

luciA = [luce1, luce2, luce3, luce4, luce5, luce6]
luciB = [luce6, luce5, luce4, luce3, luce2, luce1]

while True:
    display.show(luciA, delay=ritardo)
    display.show(luciB, delay=ritardo)

Buon Coding a tutti 🙂

Articoli correlati:

  1. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 1
  2. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 2
  3. Coding a scuola con BBC micro:bit – lezione 3
  4. Coding a scuola con BBC micro:bit – lezione 4
  5. Coding a scuola con BBC micro:bit – lezione 7

MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 2

Lascia una risposta

MicroPython è in grado di gestire la griglia di LED 5×5 (LED: light emitting diodes le lucine che si accendono sulla parte anteriore della scheda), inoltre permette il controllo sul display per creare una serie di effetti interessanti.

MicroPython è dotato di molte immagini incorporate che possono essere mostrate sul display. Ad esempio per mostrare un viso felice sul display potete digitare:

from microbit import *
display.show(Image.HAPPY)

Sicuramente ricorderete dalla lezione precedente cosa fa la prima linea. La seconda riga utilizza l’oggetto display  con il metodo show  per visualizzazione l’immagine incorporata di un viso felice chiamata HAPPY. Ciò che vogliamo mostrare è inserito tra parentesi tonde: ((  e ) ).

Ciò che segue è una lista di immagini incorporate all’interno di MicroPython che potete utilizzare all’interno dei vostri programmi:

Image.HEART
Image.HEART_SMALL
Image.HAPPY
Image.SMILE
Image.SAD
Image.CONFUSED
Image.ANGRY
Image.ASLEEP
Image.SURPRISED
Image.SILLY
Image.FABULOUS
Image.MEH
Image.YES
Image.NO
Image.CLOCK12, Image.CLOCK11, Image.CLOCK10, Image.CLOCK9, Image.CLOCK8, Image.CLOCK7, Image.CLOCK6, Image.CLOCK5, Image.CLOCK4, Image.CLOCK3, Image.CLOCK2, Image.CLOCK1
Image.ARROW_N, Image.ARROW_NE, Image.ARROW_E, Image.ARROW_SE, Image.ARROW_S, Image.ARROW_SW, Image.ARROW_W, Image.ARROW_NW
Image.TRIANGLE
Image.TRIANGLE_LEFT
Image.CHESSBOARD
Image.DIAMOND
Image.DIAMOND_SMALL
Image.SQUARE
Image.SQUARE_SMALL
Image.RABBIT
Image.COW
Image.MUSIC_CROTCHET
Image.MUSIC_QUAVER
Image.MUSIC_QUAVERS
Image.PITCHFORK
Image.XMAS
Image.PACMAN
Image.TARGET
Image.TSHIRT
Image.ROLLERSKATE
Image.DUCK
Image.HOUSE
Image.TORTOISE
Image.BUTTERFLY
Image.STICKFIGURE
Image.GHOST
Image.SWORD
Image.GIRAFFE
Image.SKULL
Image.UMBRELLA
Image.SNAKE

Sono tantissime! Provate a modificare il codice che visualizza un viso felice, è sufficiente sostituire Image.HAPPY  con una delle immagini incorporate nell’elenco sopra indicato.

 Gestire i pixel

Potete impostare la luminosità di uno specifico LED sul display utilizzando il metodo set_pixel :

from microbit import *

display.set_pixel(1,2,9)

Ricordando che la coordinata 0, 0 specifica il LED che si trova in alto a sinistra, l’istruzione indicata nel codice sopra, imposta il LED in colonna 1 e riga 2  con luminosità 9 . La luminosità può assumere un valore compreso tra 0 e 9, con 0 indichiamo spegnimento del LED e 9 massima luminosità del LED.

Allo stesso modo nel caso in cui desiderate accendere alla massima luminosità il LED che si trova in basso a sinistra, l’istruzione da utilizzare sarà:

from microbit import *

display.set_pixel(0,4,9)

Per l’accensione del LED che si trova in alto a sinistra:

from microbit import *

display.set_pixel(0,0,9)

Vediamo ora come accendere tutti i LED alla massima luminosità:

Potete utilizzare un ciclo for , così come indicato nel programma che segue:

from microbit import *

display.clear()
for x in range(0, 5):
    for y in range(0, 5):
        display.set_pixel(x,y,9)

Il ciclo for  esegue le istruzioni in esso contenuto per un numero di volte specificato, nel nostro caso nell’intervallo da   0   a 5, questa operazione viene eseguita con la funzione  range(0,5)  che restituisce la lista di interi da 0   a 4  escludendo il massimo, in questo caso il valore 5:

for x in range(0,5)

il ciclo for  sarà eseguito 5 volte, ogni volta la variabile x sarà sostituita dai valori che vanno   0   a 4  (5 valori). Si uscirà dal loop quando sarà raggiunto il valore finale dell’intervallo.

All’interno del primo for  troviamo un secondo ciclo:

for y in range(0,5):

Anche in questo caso il ciclo sarà eseguito 5 volte e la variabile y  sarà sostituita dai 5 valori da 0   a 4  . Si uscirà dal loop quando sarà raggiunto il valore finale dell’intervallo.

Vediamo ora come accendere e spegnere l’intera matrice di LED:

from microbit import *

# accensione e spegnimento di tutta la matrice di led
# dall'alto verso il basso partendo dal LED in alto a sinistra
# di coordinate (0, 0)

display.clear()
for x in range(0, 5):
    for y in range(0, 5):
        display.set_pixel(x,y,9)
        sleep(100)
for x in range(0,5):
    for y in range(0, 5):
        display.set_pixel(x,y,0)
        sleep(100)

Si noti che l’azione di spegnimento è simile a quella dell’accensione dove l’unica differenza risiede nell’istruzione: display.set_pixel(x,y,0) in cui impostiamo la luminosità a 0  .

Vediamo ora come effettuare l’accensione del display partendo dal LED situato in basso a destra alle coordinate (5, 5):

from microbit import *

# accensione e spegnimento dei LED partendo in modo orizzontale
# dal LED in posizione (5, 5) spostandosi per righe
# da destra verso sinistra

# Poiche' la funzione range restituisce una serie di valori da un
# valore minimo a un valore massimo per effettuare un decremento
# dell'indice si utilizzano le operazioni: y=4-y e x=4-x

display.clear()

for y in range(0, 5):
    y=4-y
    for x in range(0, 5):
        x=4-x
        display.set_pixel(x,y,9)
        sleep(100)

for y in range(0, 5):
    y=4-y
    for x in range(0, 5):
        x=4-x
        display.set_pixel(x,y,0)
        sleep(100)

display.clear()

Poichè la funzione range restituisce una serie di valori da un valore minimo a un valore massimo, per effettuare un decremento dell’indice si utilizzano le operazioni: y=4-y e x=4-x

Vedremo nella lezione successiva come realizzare dei cicli infiniti per realizzare giochi di luce accendendo e spegnendo i LED in modo sequenziale.

Creiamo le nostre immagini

Volete creare un’immagine personalizzata da visualizzare sul display del micro:bit?
E’ molto semplice.

La luminosità di ogni LED sul display, così come detto ad inizio lezione, può essere impostata con un valore da spento  ( 0 )  a luminosità massima  (9).

from microbit import *

luce = Image("09590:"
             "93339:"
             "93039:"
             "93339:"
             "09590")

display.show(luce)

Quando il programma è in esecuzione il dispositivo visualizza un’immagine circolare con i LED con diversa intensità luminosa:

Sicuramente avrete notato che ogni riga del display fisico è rappresentato da una linea di numeri che terminano con :  il tutto racchiuso tra doppie virgolette “

Ogni numero rappresenta la luminosità del LED a cui fa riferimento, quindi potrete specificare la luminosità per ogni LED.

Tutto molto semplice! 🙂

In realtà, non è necessario scrivere su più righe il comando per l’accensione dei LED, potete scrivere tutto su una linea sola:

luce = Image(“09590:93339:93039:93339:09590”)

Buon Coding a tutti 🙂

Articoli correlati:

  1. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 1
  2. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 3
  3. Lezione 02 – corso di programmazione in C
  4. Imparate a programmare! L’invito del Presidente Barack Obama agli americani
  5. Programmazione C++ e dintorni

MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 1

Lascia una risposta

Da diverso tempo mi sto occupando di didattica con BBC micro:bit, una splendida scheda elettronica progettata appositamente per fare Coding a scuola, ben si adatta per studenti di scuola elementare, media e primi anni delle superiori. Su questo sito come saprete ho raccolto in una sezione specifica lezioni e sperimentazioni. Recentemente è stato aggiunto a Scratch, come segnalato in qualche tempo fa, il supporto a micro:bit quindi a livello didattico si potrebbero implementare percorsi interessanti che partono da Scratch, passano per JavaScript Blocks Editor per poi giungere a MicroPython.

Dal mio punto di vista MicroPython è il trampolino di lancio che mi permetterà di aggiungere sperimentazioni di automazione con microcontrollori, un modo naturale per realizzare continuità dal secondo anno dell’ITIS al terzo/quarto anno poi. Ovviamente non solo MicroPython, tanto C anche con Arduino, ma è essenziale per me aggiungere anche questa competenza.

MicroPython è una reinterpretazione di Python 3 per microcontrollori e sistemi embedded, inoltre Python è uno dei linguaggi di programmazione più belli, ottimo per la didattica ed averlo anche su sistemi elettronici rende incredibilmente divertente ed efficiente lo sviluppo di sistemi di controllo.

Per seguire queste brevi lezioni non bisogna essere professionisti nella programmazione di Python (anche io non programmo spesso in questo linguaggio) il percorso parte da un livello 0. Il mio obiettivo è quello di fornire uno strumento che poi invogli alla sperimentazione.

La documentazione è pensata per studenti ed insegnanti di ogni ordine e grado.

MicroPython non vuol dire solo micro:bit ma anche PyBoard, ESP8266/ESP 32 e molto altro.

Pertanto ho pensato di realizzare, nel limite del tempo didattico che posso dedicare a queste piattaforme un corso introduttivo, didascalico e spero semplice. Ciò che scriverò sarà indirizzato all’uso di micro:bit, ma con qualche impostazione iniziale, tutto si adatta benissimo anche alle altre piattaforme.

Da dove incominciare?

Nei link indicati sopra trovate i riferimenti essenziali, ma un libro fondamentale è: Programming with MicroPython – by Nicholas Tollervey and pyboard lite il link rimanda ad amazon.it, l’acquisto può essere fatto anche con la 18app o con la carta del docente.

Tutto il percorso si basa sull’ottimo lavoro realizzato da Mike Rowbitt con First Steps with MicroPython ne ho fatto in parte una traduzione ed in parte ho aggiunto altri argomenti ed esercizi.

Per essere informati sulle nuove versioni del manuale in lingua inglese sviluppato da Mike Rowbitt potete iscrivervi alla mailing list: microbit@python.org
(https://mail.python.org/mailman/listinfo/microbit).

Le mie lezioni sono in costruzione, conto di pubblicare almeno un paio di guide alla settimana in modo che per chi vorrà potrà prendere questi appunti reinterpretarli secondo le proprie necessità e realizzare un percorso nella seconda parte dell’anno scolastico.

I progetti e gli esercizi sviluppati in MicroPython su BBC micro:bit fanno uso di:

Mu – un semplice editor di codice, credo che sia il modo più semplice per incominciare a programmare in MicroPython su BBC micro:bit.

Vi invito quindi a scaricare l’editor “mu” per poter lavorare con le lezioni proposte.

Tutte le istruzioni per il download e l’installazione potete trovarle sul sito di riferimento, sono ben fatte e di facile comprensione.

Mu funziona con Windows, OSX and Linux (anche Raspberry Pi).

L’ultima versione di Mu vi permette di selezionare mediante il pulsante “Modes” la modalità di programmazione in funzione della piattaforma: Adafruit CircuitPython, BBC micro:bit, Pygame Zero, Python 3.

Una volta installato Mu selezionate il modo micro:bit, collegate il vostro micro:bit al computer tramite un cavo USB.

Il processo di scrittura è upload su micro:bit richiede pochi passaggi:

  • scrivete il vostro script nella finestra dell’editor
  • fate click sul pulsante “Flash” per trasferire il programma sul micro:bit.
  • se il trasferimento non avviene, assicurati che il vostro micro:bit appaia come periferica USB nel vostro file system.

Faremo queste operazioni tra breve scrivendo un semplicissimo programma.

Prima di andare oltre un richiamo sulle caratteristiche del micro:bit riprese dal corso introduttivo che trovate su questo sito.

La scheda BBC micro:bit è costituita da:

  • 25 LED rossi che possono essere utilizzati per comporre un testo o una icona stilizzata.
  • Due pulsanti programmabili (A e B) che possono essere utilizzati per dire a micro:bit quando si avvia o si interrompe un’operazione.
  • Un sensore di temperatura per rilevare la temperatura ambiente.
  • Un sensore di luce per rilevare le variazioni di luminosità ambientale.
  • Un accelerometro per rilevare un movimento.
  • Un magnetometro per rilevare la direzione del campo magnetico.
  • Connessione Radio e Bluetooth Low Energy per interagire con altri device.

Il primo programma – “Hello World!”

E’ possibile pensare al Coding con micro:bit come ad un ciclo costituito fa 4 fasi:

Il modo tradizionale per iniziare a programmare in una nuova lingua di programmazione è quello di far dire al computer “Hello, World!”.

Fare questo è semplice in MicroPython:

from microbit import *
display.scroll("Hello, World!")

Analizziamo le due linee di codice.

La prima linea:

from microbit import *

Nella prima riga viene richiesto a MicroPython tutto il materiale (codice) necessario per lavorare con micro:bit. Il codice richiesto è un modulo chiamato microbit  (un modulo è una libreria di codice preesistente). Quando fate l’import  (importate qualcosa), state dicendo a MicroPython che volete usarlo, “*” è il modo in cui Python dice tutto.
Quindi from microbit import *  significa, in inglese, “Voglio poter usare tutto ciò che è disponibile dalla libreria di codici microbit”.

Seconda linea:

display.scroll(“Hello, World!”)

dice a MicroPython di usare il display per far scorrere la stringa di caratteri.

La parte di codice display  permette la visualizzazione del testo Hello, World!  .

display  è un oggetto dal modulo microbit che rappresenta la visualizzazione fisica del testo “Hello, World!” sul dispositivo.

La parte di codice indicata con display  è un object (oggetto) del modulo microbit  che rappresenta il display fisico. Possiamo dire al display di eseguire l’operazione indicata fino al .  dopo il .  è presente qualcosa di molto simile ad un comando (che chiameremo metodo). In questo caso stiamo usando il metodo scroll  (scorrimento). Poiché scroll  ha necessità di sapere quali caratteri far scorrere sul display fisico, questi saranno specificati tra doppie virgolette (“) tra parentesi ( (  e )  ). Tutto ciò che è tra parentesi e tra le virgolette prende il nome di argomento. Quindi, display.scroll(“Hello, World!”)   significa, in inglese, “Voglio che tu usi il display per far scorrere il testo ‘Hello, World!'”. Se un metodo non ha bisogno di argomenti non inseriremo nulla tra parentesi: ()  .

Copiate all’interno dell’editor il codice “Hello, World!” ed eseguite l’upload sul vostro BBC micro:bit.

Siete in grado di capire come cambiare messaggio?

Potete farlo salutare? Ad esempio, potreste far dire “Ciao, Michele!”.
Suggerimento: è necessario modificare l’argomento del metodo di scroll. 🙂

Avvertimento

Potrebbe non funzionare 🙂

Nel caso in cui venga commesso un errore MicroPython ci viene in aiuto, in questo caso scorrerà sul display del micro:bit un messaggio di errore, sempre sul display apparirà il numero della linea di codice in cui è presente l’errore.

Python si aspetta che voi digitiate ESATTAMENTE il codice. Quindi, ad esempio l’istanza, Microbit  , microbit  e microBit  sono tutte cose diverse per Python. Se MicroPython restituisce un errore NameError  , probabilmente avete digitato qualcosa in modo non corretto.

Se MicroPython restituisce un SyntaxError  probabilmente avete scritto qualcosa che MicroPython non riesce a capire. Verificate che non manchino ad esempio i caratteri speciali “  o :  .

Usiamo Mu

Colleghiamo il micro:bit al computer:

Utilizziamo Mu per codificare:

Un click sul pulsante Repl per estendere la finiestra di editing e visualizzare l’area in cui vengono mostrati i messaggi inviati dal micro:bit

Per trasferire il programma sul micro:bit click sul pulsante “Flash”:

Durante la fase di trasferimento del programma il led giallo di stato incomincia a lampeggiare al termine il micro:bit verrà disconnesso dal computer ed immediatamente il programma incomincerà a funzionare:

Nel caso in cui nel vostro programma sia presente un errore, nella parte bassa della finestra di editing vi verrà restituito un messaggio che indica il tipo di errore. Usando il comando help() potrete consultare una guida che vi aiuterà a risolvere il problema.

Nel caso di errore sul display del micro:bit apparirà il messaggio di errore.

Buon Coding a tutti 🙂

Articoli correlati:

  1. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 2
  2. MicroPython – Python per microcontrollori – usarlo su BBC micro:bit – lezione 3
  3. Coding a scuola con BBC micro:bit – lezione 1
  4. Coding a scuola con BBC micro:bit – lezione 4
  5. BBC micro:bit – Disponibile Javascript Blocks in versione standalone per Windows 10