Programmiamo ESPertino con Lua

Anche se non a tutti noto, Lua è un linguaggio di scripting particolarmente indicato per le applicazioni di tipo embedded. Semplicità, portabilità, ridotte dimensioni del codice e performance di assoluto rilievo, sono alcune tra le sue principali caratteristiche. ESPertino, la board di prototipazione rapida che abbiamo già imparato a conoscere attraverso numerose utili applicazioni, permette di essere programmata anche in Lua, con pieno accesso alle sue funzionalità hardware e alla connettività

Il linguaggio Lua

Lua è un linguaggio di scripting caratterizzato da proprietà quali potenza, efficienza, e compattezza, ed è quindi particolarmente adatto ad essere utilizzato nei sistemi embedded. I programmi scritti in Lua vengono eseguiti interpretando il codice (detto anche bytecode) tramite una macchina virtuale basata esclusivamente su registri: Lua rappresenta quindi la scelta ideale per tutte le applicazioni di configurazione, scripting, e prototipazione rapida. Lua è stato ideato, implementato, e costantemente aggiornato da un team di sviluppatori presso l’università PUC (Pontifical Catholic University) di Rio de Janeiro, in Brasile. Lua in portoghese significa “Luna”, il satellite naturale del nostro pianeta. In Figura 1 possiamo vedere il logo di Lua, che simboleggia appunto una Luna in orbita attorno al pianeta terra.

Figura 1: il logo di Lua

Tra i principali campi di applicazione del linguaggio Lua ricordiamo:

  • sistemi embedded – Lua è stato utilizzato con successo in alcuni modelli commerciali di televisori, router, tastiere, stampanti, set-top box, calcolatrici programmabili, dispositivi mobile e M2M;
  • linguaggio di scripting per applicazioni (estensioni e plugin) – numerose applicazioni utilizzano Lua come linguaggio di scripting. Qualche esempio: Wireshark, VLC Media Player, Snort (Network Intrusion Detection & Prevention Sytem), Nmap (Network Mapper), lighttpd (web server), Adobe Photoshop Lightroom (circa il 63% di questo programma, corrispondente ad oltre un milione di righe di codice, è scritto in Lua);
  • gaming – attualmente Lua può essere ritenuto come il principale linguaggio di scripting utilizzato nel settore dei videogiochi. L’immagine di Figura 2 rende soltanto un’idea approssimativa della quantità e della qualità di alcuni tra i numerosi titoli di videogiochi basati su Lua.

Figura 2: alcuni titoli di videogiochi basati sul linguaggio di scripting Lua

I punti di forza del linguaggio Lua possono essere così sintetizzati:

  • embeddabilità” – l’interprete Lua è scritto in ANSI C (viene fornito sotto forma di libreria) ed è quindi facilmente compilabile su ogni piattaforma di tipo embedded con una quantità minima di CPU e di memoria disponibile;
  • portabilità – Lua gira praticamente su ogni tipo di architettura hardware, con o senza sistema operativo, e sui sistemi embedded di tipo custom;
  • semplicità – Lua dispone di una sintassi molto semplice che ne consente l’utilizzo anche da parte dei neofiti nel campo della programmazione. Il manuale del linguaggio (circa un centinaio di pagine) contiene una descrizione dettagliata delle funzionalità della parte core, delle librerie, e delle API offerte dal linguaggio;
  • compattezza – l’intera distribuzione (codice sorgente) occupa poco più di 200 kB e conta meno di 18 mila linee di codice, mentre la dimensione del file binario è inferiore a 200 kB;
  • efficienza – la compattezza e la semplicità di Lua si traducono di riflesso in un’ottima efficienza del linguaggio. Anche se non comparabile a quella dei linguaggi C e C++ compilati, siamo sicuramente ad un livello superiore rispetto ad altri linguaggi di scripting come Perl o Python. Numerosi benchmark hanno indicato Lua come il linguaggio più efficiente tra quelli interpretati con tipizzazione dinamica;
  • è un software open source – Lua è un progetto software open source, distribuito con una licenza molto libera (MIT license). Può quindi essere liberamente scaricato ed utilizzato in qualunque tipo di applicazione, anche di tipo commerciale, senza alcun costo.

Lo scopo di questo articolo è mostrare come il linguaggio Lua possa essere efficacemente utilizzato anche sulla board di prototipazione rapida ESPertino. Non ci soffermeremo più di tanto sui costrutti e sulla sintassi del linguaggio, anche se la nutrita serie di esempi che tra poco vedremo consentirà anche ai neofiti di prendere piena confidenza con il linguaggio. Per una presentazione approfondita dello stesso, il lettore può fare riferimento ai link [1]-[2] (in particolare il secondo), e alle numerose guide disponibili in rete (anche in italiano).

Lua RTOS

Lua RTOS per ESP32, disponibile per il download o il clone git su GitHub, è un progetto open source nato da un gruppo di appassionati che ha eseguito il “porting” di un interprete Lua su piattaforme basate sul modulo ESP-Wroom-32 di Espressif Systems (e quindi utilizzabile anche su ESPertino, compatibile con la scheda ESP Core classica). Sappiamo che ESPertino può essere programmata attraverso l’IDE di Arduino, ma questa non rappresenta l’unica opzione disponibile per scrivere un’applicazione per il modulo ESP32. Si può ad esempio utilizzare il framework nativo sviluppato dal produttore (l’ESP-IDF), che abbiamo già avuto modo di installare e utilizzare nell’articolo relativo alla funzionalità OTA per ESPertino. E’ ora giunto il momento di utilizzare Lua!

Lua RTOS è un sistema operativo real time progettato per girare su sistemi embedded, caratterizzati in genere da una disponibilità minima di memoria flash e ram. Attualmente, Lua RTOS è disponibile per le piattaforme hardware ESP32, ESP8266, e PIC32MZ, ma è possibile eseguire facilmente il porting su altri sistemi a 32 bit.

Come visibile in Figura 3, Lua RTOS è suddiviso in tre livelli:

  1. il livello superiore è rappresentato dall’interprete Lua (la versione attuale è la 5.3.4), che mette a disposizione dello sviluppatore le risorse di base fornite dal linguaggio Lua, oltre ad alcuni moduli che consentono di eseguire l’accesso all’hardware (PIO, ADC, I2C, RTC, e altri ancora) e ad alcuni servizi forniti da Lua RTOS (thread, interfaccia di rete LoRa, protocollo MQTT, ecc.);
  2. il livello intermedio è rappresentato da un micro kernel Real Time, basato sul noto sistema operativo FreeRTOS. Il micro kernel serve a garantire che tutte le attività vengano eseguite nei tempi attesi e prestabiliti. Per chi non ne fosse già a conoscenza, ricordiamo che il framework ESP-IDF sviluppato da Espressif è proprio basato su FreeRTOS, che quindi è l’ambiente nativo scelto per il modulo ESP32. Di fatto, anche l’IDE Arduino (in modo del tutto trasparente allo sviluppatore) genera del codice che viene eseguito proprio in questo ambiente;
  3. il livello inferiore non è altro che un’astrazione dell’hardware, e si occupa di dialogare direttamente con le risorse di basso livello presenti sulla piattaforma di prototipazione.

Figura 3: i livelli su cui si compone il sistema di sviluppo (e prototipazione software) Lua RTOS

L’adozione di questa struttura a più livelli comporta un vantaggio considerevole: qualora infatti si decidesse di eseguire il porting verso altre piattaforme hardware, sarebbe sufficiente scrivere il codice soltanto per il livello inferiore, in quanto sia il livello superiore che quello intermedio rimangono inalterati su tutte le diverse piattaforme.

Installazione

Prima di installare Lua RTOS sulla scheda ESPertino occorre soddisfare alcuni pre-requisiti:

  1. occorre avere installato il driver per il convertitore USB-seriale presente sulla scheda ESPertino, più precisamente il Silicon Labs CP210x. Potete fare riferimento alla pagina web [3] per la procedura, che dipende dal particolare sistema operativo installato sul vostro PC. Se avete già programmato ESPertino (ad esempio tramite l’IDE Arduino, come proposto in diversi articoli precedenti apparsi su EOS), questo passo non è necessario e potete passare al successivo;
  2. occorre avere installato il framework ufficiale Espressif per lo sviluppo su ESP32 (ESP-IDF) [4]. Per le istruzioni relative a questo punto (e al precedente) si rimanda all’articolo pubblicato su EOS “Aggiorniamo ESPertino con l’OTA”;
  3. occorre installare esptool, il programma di utilità che permette di programmare la flash del modulo ESP32. Per l’installazione di esptool è sufficiente seguire le istruzioni riportate in [5]. L’operazione è comunque immediata: da una shell (aperta ad esempio nell’ambiente msys2) è infatti sufficiente digitare il comando:
    
    $ pip install esptool
    
    

Siamo a questo punto pronti per installare su ESPertino l’ambiente di sviluppo per Lua. Le opzioni disponibili sono due: compilare i sorgenti disponibili su GitHub, oppure scaricare il firmware precompilato e utilizzarlo per programmare la flash. Abbiamo optato per la seconda soluzione, più semplice, immediata, e meno laboriosa rispetto alla prima. In questo caso è sufficiente accedere all’indirizzo [6], per scaricare sul proprio PC un file compresso contenente tutti i file binari relativi alla board ESP CORE (compatibile con ESPertino). Decomprimiamo questo file, e copiamo tutta il contenuto in una cartella a nostro piacimento sull’hard disk (posta ad esempio allo stesso livello della cartella esp-idf, in modo da raggruppare in un unico punto tutti i tool di sviluppo per la scheda ESPertino).

Apriamo poi una shell nell’ambiente msys2 (lanciando mingw32.exe), posizionamoci nella cartella contenente i file binari di Lua RTOS (utilizzando i consueti comandi della shell Linux), ed eseguiamo i due comandi seguenti:


python ${IDF_PATH}/components/esptool_py/esptool/esptool.py --chip esp32 --port "COM14" --baud 921600 --before "default_reset" --after "hard_reset" write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x1000 bootloader.ESP32-CORE-Board.bin 0x10000 lua_rtos.ESP32-CORE-BOARD.bin 0x8000 partitions_singleapp.ESP32-CORE-BOARD.bin

e successivamente (dopo che la scheda si sarà riavviata automaticamente):


python ${IDF_PATH}/components/esptool_py/esptool/esptool.py --chip esp32 --port "COM14" --baud 921600 --before "default_reset" --after "hard_reset" write_flash -z --flash_mode "dio" --flash_freq "40m" --flash_size detect 0x180000 spiffs_image.ESP32-CORE-BOARD.bin

La variabile di ambiente IDF_PATH punta al percorso in cui avete installato l’ambiente di sviluppo sul vostro PC (come indicato nell’articolo sulla funzionalità OTA di ESPertino), mentre la porta seriale “COM14” andrà sostituita con quella allocata dal sistema operativo sul vostro computer. L’output dei due comandi, catturato nella shell msys2, è visibile nelle Figure 4 e 5, rispettivamente.

Figura 4: output nella shell msys2 del primo comando di download

Figura 5: output nella shell msys2 del secondo comando di download

Diamo ora un reset alla board ESPertino (un primo reset è già stato dato automaticamente dallo script di download), per verificare che quanto scaricato sulla scheda sia stato correttamente memorizzato sulla memoria flash. Collegandoci tramite un comune monitor seriale (ad esempio teraterm, impostato sulla velocità 115200 bit/sec), dovremmo finalmente vedere comparire lo splashscreen di Lua (Whitecat è il nome del progetto), alcune informazioni di stato, e il prompt utente (Figura 6).

Figura 6: la splashscreen di Witecat Lua

Un aspetto molto importante di questa versione embedded di Lua è quello di disporre di un vero e proprio file system, creato sulla memoria flash del modulo ESP32. Il file system si basa sul progetto open source spiffs [7] (acronimo di SPI Flash File System), che tra le varie funzionalità implementa anche un algoritmo di “wear leveling” (usura distribuita della flash), distribuendo uniformemente le scritture sulla memoria flash SPI prolungandone così la durata. Rompiamo subito gli indugi, e prendiamo dimestichezza con la shell dei comandi Lua e con il file system come indicato in Figura 7. Una lista dettagliata dei comandi disponibili è descritta nell’apposita sezione del progetto su GitHub, che consiglio di consultare, come anche le pagine elencate nel menu posto sulla destra della stessa pagina web.

Figura 7: esecuzione di alcuni comandi nella shell Lua RTOS

Programmi di esempio

Il modo più semplice per apprendere un nuovo linguaggio di programmazione è sicuramente quello di scrivere e provare qualche programmino di esempio, misurando e testando i progressi compiuti tramite la verifica dei risultati ottenuti. Come visibile in Figura 7, gli sviluppatori del progetto Whitecat (Lua RTOS) ci sono venuti incontro, e all’interno del file system spiffs hanno già predisposto alcuni programmi di esempio.

Hello World!

Come la tradizione insegna, il primo programma di test è il classico “Hello world!”, il cui obiettivo è visualizzare sulla console l’omonima stringa di test. Dobbiamo anzitutto accedere alla cartella /examples/lua (vedi Figura 7 per i relativi comandi), dove sono già presenti alcuni programmi di test, ma non “Hello World!”. Dovremo quindi crearlo da zero. Whitecat Lua RTOS include un editor, che possiamo invocare tramite il comando edit:


/examples/lua > edit hello_world.lua

inseriamo quindi nel file la seguente ed unica istruzione Lua:


print(“Hello World!”)

salviamo e usciamo dall’editor tramite la sequenza di comandi Ctrl+S e Ctr+Q (premendo Ctrl+Y all’interno dell’editor vengono visualizzati tutti i comandi disponibili). Digitando il comando “ls” nella shell Lua, potremo ora verificare che il file è stato regolarmente creato. Per eseguirlo è sufficiente digitare il comando hello_world.lua e premere Invio: verrà visualizzata nella shell la stringa di caratteri attesa.

Blink

Questo è un altro programma classico, a cui siamo stati abituati lavorando con Arduino. Poichè ESPertino dispone di un led integrato sulla scheda, collegato al GPIO5, possiamo scrivere un programmino di esempio per farlo lampeggiare a intervalli di tempo regolari. Partiamo dunque dal programma blink.lua già presente nella cartella /examples/lua, e apriamolo tramite l’editor, come indicato in Figura 8. Dovremo ora sostituire il GPIO14 con GPIO5, quindi salvare e uscire dall’editor. Eseguendo poi il programma (basterà digitare blink.lua) vedremo il led di ESPertino lampeggiare. Se volete, potete provare a modificare la frequenza del lampeggio mettendo al posto di 100 un valore differente nell’istruzione:


tmr.delayms(100)

Figura 8: il programma blink.lua prima della modifica per ESPertino

Pwm

In questo esempio vogliamo utilizzare il PWM (Pulse Width Modulation) per variare progressivamente la luminosità del led della board ESPertino, producendo un risultato simile a quello di una stella pulsante. Carichiamo dunque nell’editor il programma pwm.lua, il cui contenuto è visibile in Figura 9. Sostituiamo poi GPIO26 con GPIO5, salviamo e usciamo dall’editor. Lanciamo quindi il programma, e vedremo subito un effetto appariscente di dissolvenza della luminosità del led, meglio apprezzabile in condizioni di scarsa luminosità.
[...]

ATTENZIONE: quello che hai appena letto è solo un estratto, l'Articolo Tecnico completo è composto da ben 2961 parole ed è riservato agli abbonati MAKER. Con l'Abbonamento avrai anche accesso a tutti gli altri Articoli Tecnici MAKER e potrai fare il download (PDF) dell'EOS-Book del mese. ABBONATI ORA, è semplice e sicuro.

Abbonati alle riviste di elettronica

Scrivi un commento

EOS-Academy