Non ci sono prodotti a carrello.
Conosciamo la versione di Python che consente di programmare i microcontrollori con questo potente linguaggio.
La programmazione dei microcontrollori avviene (normalmente) attraverso linguaggi “compilati”. Ciò significa che il linguaggio utilizzato per la programmazione (ad esempio il C o il C++) non può essere caricato direttamente nel dispositivo, ma necessita di un software compilatore in grado di convertire il codice sorgente (ad esempio file.c e file.h) nel linguaggio macchina (vale a dire in codice binario).
Questo passaggio permette di ottenere un file esadecimale (se non ci sono errori di compilazione) che può essere caricato direttamente sul microcontrollore e da questo viene poi eseguito. Tuttavia, sempre più piede stanno prendendo i linguaggi interpretati, come ad esempio Python.
Questa tipologia di linguaggi utilizza un software chiamato, per l’appunto, interprete, il quale traduce le istruzioni (ovvero il codice da noi scritto) in modalità runtime direttamente sul device di destinazione.
Python è un linguaggio interattivo orientato agli oggetti, in cui il codice viene tradotto e interpretato e può essere eseguito su qualsiasi piattaforma (intesa come architettura di computer) purché abbia installato l’interprete Python.
Ma Python non è solo questo, o meglio, non è confinato all’ambiente dei computer.
Difatti in queste pagine andremo a presentarvi MicroPython: una versione di Python 3 molto snella ed efficiente ottimizzata per girare sui microcontrollori (il sito Internet di riferimento è micropython.org).
Questo linguaggio è molto semplice da utilizzare e permette di assimilare in poco tempo le basi per poter sviluppare codice potente che in linguaggi come il C risulterebbero abbastanza complessi .
Per farvi capire le capacità di Python metteremo alla prova le sue potenzialità sulla board NODEMCU (lo vedete in Fig. 1), la quale è equipaggiata con il famosissimo chip ESP8266, ossia un microcontrollore molto potente con modulo WiFi integrato e in grado di essere programmato per eseguire codice adatto alle applicazioni IoT.
Fig. 1 La board NODEMCU ESP8266.
Preparare l’ambiente micropython
Prima di iniziare dobbiamo assicurarci di avere tutti gli strumenti necessari, quindi per prima cosa installiamo Python 3.4 o versioni successive dalla pagina web www.python.org/downloads scegliendo le impostazioni personalizzate e selezioniamo “install for all user” verificando che Python venga installato nella directory dei programmi.
Diamo per scontato di lavorare su Microsoft Windows. Apriamo ora il prompt DOS in modalità amministratore (tasto dx mouse > esegui come amministratore) e rechiamoci nella directory di Python, quindi inviamo il comando:
pip install – upgrade esptool
Attenzione che con alcune versioni di Python il comando potrebbe non funzionare! Nel caso provate con questi:
pip3 install esptool
python -m pip install esptool
pip2 install esptool
Se tutto è andato a buon fine dovremmo trovare il file esptool.py nella cartella predefinita di python\Scripts. Dando quindi il comando esptool.py, dovremmo visualizzare la schermata visibile in Fig. 2.
Scarichiamo ora l’ultima versione dell’immagine con estensione “.bin” del firmware micropython.org/download/#esp8266 che andremo a flashare (installare) sul nostro NODEMCU.
Fig. 2 Esito del comando esptool.py.
Per comodità spostiamo il file scaricato nella cartella di Python.
L’immagine ci permetterà di far “girare” gli script di Python sulla nostra scheda.
Ora che abbiamo tutti gli strumenti passiamo al lato pratico: dobbiamo verificare che il nostro PC sia in grado di rilevare correttamente la scheda, perciò colleghiamo il cavo USB alla board e verifichiamo in “gestione dispositivi” di Windows su quale porta COM è stato riconosciuto il NODEMCU (Fig. 3).
Prendete nota della porta aggiunta (perché ci servirà a breve) che nel caso dell’esempio qui proposto è la COM4.
Fig. 3 La COM installata.
Windows dovrebbe essere in grado di installare il driver USB senza problemi; nel caso in cui il NODEMCU non sia rilevato correttamente, bisognerà installare il driver manualmente.
Da questo momento siamo pronti ad inviare il primo comando verso il modulo: come prima cosa cancelliamo la flash del micro ESP8266 installato sulla board tramite lo script esptool.py:
esptool.py –port COM4 erase_flash
Se dovesse apparire la scritta “connecting….___ “ dobbiamo premere per mezzo secondo il pulsante di reset presente sulla board.
Come vediamo nella Fig. 4, il comando permette di pulire totalmente la memoria di programma (“erasing flash”…) da eventuali firmware installati e riporta il modulo nelle condizioni come fosse appena uscito dalla fabbrica.
Installiamo quindi l’immagine del firmware “MicroPython” che servirà ad interpretare il codice python:
esptool.py –port COM4 –baud 460800 write_flash –flash_size=detect 0 esp8266-20190125-v1.10.bin
Attualmente la versione dell’immagine è “esp8266-20190125-v1.10.bin”.
In caso ci siano nuove versioni basterà, sostituire la stringa cambiando la parte finale con il nome della nuova immagine scaricata.
La Fig. 5 mostra il risultato del comando inviato; se analizziamo cosa appare a video, possiamo notare il nome del chip (ESP8266) e la conferma positiva del comando inviato.
A questo punto abbiamo finalmente installato MicroPython sulla nostra board.
Fig. 4 Cancellazione della Flash.
Fig. 5 MicroPython è stato installato!
Facciamo dunque un po’ di pratica inviando dei comandi. Per farlo ci servirà un terminale ed allo scopo possiamo usare PuTTY, Teraterm o simili.
Per chi non lo sapesse, quando parliamo di terminale, parliamo di un software in grado di mettere in comunicazione due dispositivi attraverso un protocollo. Nel nostro caso abbiamo la necessità di utilizzare la seriale (visto che la board dovrà prendere i comandi dal PC attraverso il cavo USB). Noi useremo PuTTY, scaricabile direttamente da www.putty.org.
Entriamo nella configurazione e, come proposto nella Fig. 6, selezioniamo l’ultima voce per impostare la COM corretta, il baudrate a (115200) e disabilitare il “flow control.
Selezioniamo ora la voce “Session” (la prima in alto Fig. 7) e come “connection type” scegliamo “Serial”, impostiamo poi la COM corretta (nel nostro caso era COM4) e come “speed” inseriamo 115200 (che è il nostro baud-rate); per comodità, se volete potete dare anche un nome al profilo (in “Save session”) e salvarlo.
In questo modo ogni volta che riapriremo PuTTY ci basterà cliccare su “Load” per caricare le impostazioni salvate in precedenza. Infine fate clic sul pulsante “Open” in basso a destra.
Fig. 6 Impostazione della COM e del baud-rate.
Fig. 7 Completamento impostazioni del terminale.
Se abbiamo eseguito tutti i passaggi dovremmo essere connessi al modulo in seriale: proviamo ad inviare il seguente comando in Python (Fig. 8):
print (“ciao a tutti da …”)
Vi ricordiamo inoltre di non aggiungere spazi prima del “print”, altrimenti Python ci segnalerà un errore d’indentazione del codice.
Il vantaggio di usare MicroPython è di avere a disposizione un file-system interno memorizzato nella flash; se vi state chiedendo a cosa possa servire ciò, vi rispondiamo che è utile per gestire gli script che svilupperemo sul nostro computer e che trasferiremo di volta in volta sulla board tramite porta seriale oppure con l’interfaccia web WebREPL che vedremo a breve.
Il modulo NODEMCU può funzionare da “station” (ovvero il modulo è connesso alla nostra rete WiFi), da “access point” (il modulo diventa una rete a cui noi ci connettiamo) o da entrambe le modalità. Se vogliamo continuare ad utilizzare internet e connetterci al modulo tramite la nostra rete WiFi, dobbiamo utilizzare l’interfaccia “station”. Per farlo configuriamo il modulo WiFi con questi semplici comandi:
import network
ssid = “Nome della tua rete”
password = “Password della tua rete”
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.scan()
wlan.connect(ssid, password)
Fate bene attenzione all’ultimo comando, in quanto è quello che ci permetterà di collegare il nostro modulo alla rete. Verifichiamo che l’interfaccia sia attiva tramite il seguente comando:
wlan.active()
Il modulo risponderà True se la connessione è stata stabilita. Chiediamo al modulo l’indirizzo ip, netmask, gateway, DNS tramite il comando:
wlan.ifconfig()
Otterremo così una risposta simile a questa:
‘192.168.4.1’, ‘255.255.255.0’, ‘192.168.4.1’, ‘8.8.8.8’
Arrivati a questo punto, la nostra board è connessa in WiFi e può accedere alla rete Internet.
Fig. 8 Risposta del modulo al comando inviato.
Utilizziamo webREPL
Andremo ora a utilizzare WebREPL, non prima di avervi introdotto il suo funzionamento.
Esso permette di utilizzare il prompt di Python attraverso il WiFi e quindi senza inviare i comandi dalla seriale.
Come potete vedere nella Fig. 9, sulla parte destra della schermata è presente una sezione dalla quale è possibile inviare file alla board ed anche riceverli salvandoli sul Personal Computer; tutto questo grazie al file-system di MicroPython installato.
Fig. 9 Sezione di ricetrasmissione di file al NODEMCU.
WeBREPL client è disponibile alla pagina micropython.org/webrepl e attualmente l’ultima versione disponibile dal sito ufficiale è supportata sia da Firefox che da Chrome.
In alternativa, è anche possibile scaricarlo localmente dal repository di GitHub github.com/micropython/webrepl.
Nel caso che non si riesca a cambiare l’indirizzo IP, consigliamo di scaricare localmente la versione WebREPL e avviare dalla cartella il file “webrepl.html” facendo così il problema viene aggirato.
Per consentire a NODEMCU di collegarsi a WebREPL dobbiamo inviargli questo comando da terminale:
import webrepl_setup
Il comando permetterà di far apparire a video le impostazioni di setup per avviare, ad ogni accensione della board, WebREPL-deamon.
A questo punto:
• digitare E (Enable) e premere invio per abilitare auto-start;
• inserite una password e confermatela;
• digitate y (Yes) e premete invio per eseguire il reboot del modulo.
Notate che una volta che è stato eseguito il reboot, l’indirizzo IP potrebbe cambiare. Questo è dovuto alla configurazione del vostro router/Access Point.
Vi consigliamo di entrare nelle impostazioni del vostro AP e assegnate un indirizzo IP fisso al MAC address del NODEMCU, in questo modo ad ogni riavvio della board, il vostro AP assegnerà sempre lo stesso indirizzo IP alla scheda (questa operazione potrebbe richiedere anche 20 secondi, quindi aspettate prima di inviare i comandi per richiedere l’indirizzo IP).
Per verificare se l’indirizzo IP è stato cambiato impartite questi comandi:
import network
wlan = network.WLAN(network.STA_IF)
wlan.ifconfig()
Come prima questo comando ci permette di conoscere l’indirizzo IP della scheda.
Inseriamo l’indirizzo IP esistente sulla pagina web di WebREPL (Fig. 10) e facciamo clic sul pulsante Connect.
MicroPython ci darà il benvenuto.
Adesso ricordatevi di inserire la password (che avete impostato in precedenza) e di premere Invio.
Se non appare la richiesta di password, non preoccupatevi: inseritela lo stesso e premete Invio; sarà il modulo a verificare la correttezza di essa.
Appena connessi possiamo subito notare che qualsiasi cosa scriviamo sulla pagina web (e quindi in WiFi) viene scritta anche a video nella schermata del terminale PuTTY (e quindi in seriale).
Fig. 10 Introduzione di un nuovo indirizzo IP per il NODEMCU.
Carichiamo un file
Dato che abbiamo a disposizione il file-system possiamo caricare o scaricare i file con la nostra board.
Creiamo un file di nome “test.txt” inserendo una stringa a piacere ad esempio:
‘Ciao a tutti da Micropython!!!!!’
e salviamolo sul desktop.
Portiamoci ora sull’interfaccia di WebREPL; come possiamo vedere, in alto a destra è mostrata la scritta Send a file (riferitevi alla già vista Fig. 9); qui facciamo clic sul pulsante “Sfoglia” e procediamo caricando il file “test.txt”.
Infine facciamo clic sul pulsante “send to device”.
Quasi per magia, vedremo che il file di testo è stato caricato sulla nostra board.
Verifichiamo che sia davvero stato salvato nel modo corretto, impartendo i seguenti comandi:
import os
os.listdir()
Ed ecco la risposta:
[‘boot.py’, ‘webrepl_cfg.py’, ‘test.txt’]
Il primo di questi comandi permette di importare la libreria del file system mentre il secondo “os.listdir()” esegue una vera e propria scansione rilevando i file presenti sulla board e li mostra a video nella riga successiva.
Diamo ora i comandi che permettono di aprire il file in lettura e leggerne il contenuto.
f = open(‘test.txt’)
f.read()
Con questi comandi abbiamo assegnato il nome del file ad una variabile, infine con il metodo “f.read”, abbiamo mostrato a video il contenuto del file
Ed ecco la risposta:
‘Ciao a tutti da Micropython!!!!!’
Infine proviamo ora ad ottenere il file dalla nostra board;
• dove è mostrata la scritta “Get a file” inseriamo nella casella di testo il nome “test.txt”,
• facciamo clic sul pulsante “Get from device”; se abbiamo digitato correttamente il nome, noteremo che il browser ci chiederà se salvare o aprire il file “test.txt”.
In questo caso ci basterà aprirlo e verificare che sia presente nel file la stringa seguente:
‘Ciao a tutti da Micropython!!!!!’
Se lo è possiamo ritenere conclusa l’operazione.
Conclusioni
Bene, finisce qui questo tutorial attraverso il quale vi abbiamo introdotto MicroPython, spiegandovene i fondamenti e l’utilizzo di massima su un sistema a microcontrollore come il NODEMCU basato su ESP8266.
Quelli proposti sono stati semplici esempi per darvi le basi; lasciamo a voi il piacere di fare “allenamento” inviando script, facendo pratica con i GPIO della della scheda e quant’altro volete.
Non ci resta che augurarvi buon lavoro!
