Con jolly l’arduino uno diventa wi-fi

 

Presentiamo Jolly, un add-on per dotare la più famosa board open-source della funzionalità Wi-Fi.

La scheda Arduino UNO è ormai entrata a pieno titolo nella storia dell’elettronica, ma da quando è nata sono stati compiuti passi da gigante nel mondo della comunicazione, soprattutto wireless, nell’ambito dell’automazione domestica.

Jolly è un modulo elettronico costituito da un micro PCB che può essere inserito in una board Arduino UNO, al posto del microcontrollore originale; essendo dotato di Wi-Fi integrato, può estendere all’infinito le potenzialità dei progetti esistenti nel nuovo mondo dell’IoT.

Infatti, grazie a questo modulo, la stessa board viene trasformata in un dispositivo IoT. Il modulo può essere usato anche separatamente dalla board, in modalità stand-alone, esattamente come il microcontrollore ATmega328P-PU.

Dotare una board Arduino UNO di questo modulo significa darle una nuova dimensione, adeguata alle odierne esigenze in materia di comunicazione e automazione domestica.

Tutti coloro che in questi anni hanno trovato in Arduino UNO e nelle schede compatibili la giusta piattaforma per creare progetti e oggetti, cioè hobbisti, studenti, appassionati, programmatori e professionisti, dovrebbero effettuare questo upgrade, per sfruttarne le enormi potenzialità.

Una delle caratteristiche fondamentali è il mantenimento della piena compatibilità del pinout, del firmware e dell’architettura hardware dei progetti esistenti.

 

 

 

Caratteristiche tecniche del modulo Jolly

Il modulo è stato progettato principalmente per espandere le funzionalità offerte dall’Arduino UNO, trasformandolo in un moderno dispositivo IoT senza alterarne le caratteristiche e mantenendo la compatibilità con la board originale. Il modulo è poco più grande del microcontrollore originale della board, infatti le sue dimensioni esterne sono 41 x 10 mm (Fig. 2).

 

Poiché il modulo sostituisce l’ATmega328P nell’Arduino UNO, per poterlo realizzare con dimensioni compatibili, è stato necessario utilizzare la sua versione SMD più recente, chiamata ATmega328PB-MU, che comunque garantisce la piena compatibilità della piedinatura, del firmware e dell’architettura hardware del suo predecessore, ma in uno spazio molto più ridotto.

Questo ha permesso di poter aggiungere un ulteriore microcontrollore, l’ESP8285, equivalente all’ESP8266 ma con una flash integrata da 2 MB, caratteristica essenziale per mantenere le dimensioni della scheda ridotte.

Inoltre è stato necessario integrare anche un circuito di regolazione della tensione ed un level shifter (adattatore di livello dei segnali digitali) poiché i due microcontrollori funzionano con differenti tensioni di alimentazione (5 V per l’ATmega328PB e 3,3 V per l’ESP8285). Il modulo è dotato di un LED BUILTIN e di un’antenna integrata per il Wi-Fi (Fig. 3).

 

 

L’unica limitazione (approfondiremo questo aspetto più avanti) è data dal fatto che i due microcontrollori sono collegati tra loro attraverso due interfacce digitali: una SPI e una UART.

In particolare, l’interfaccia SPI, che è la stessa esposta sulla piedinatura del modulo, è utilizzata per lo scambio di dati, mentre la UART, è appannaggio esclusivo della programmazione, sia per l’ATmega328PB che per l’ESP8285.

L’interfaccia seriale di quest’ultimo è attiva solo durante la fase di programmazione per non interferire con il normale funzionamento della seriale dell’ATmega328PB (Fig. 4).

 

 

La programmazione del solo chip WiFi è possibile grazie alla presenza di una specifica chiave di avvio e di un firmware speciale nell’ATmega328PB.

La presenza dei componenti sulla sola faccia superiore del PCB rende questa scheda perfetta anche per l’uso in modalità stand-alone. Per l’aggiornamento del firmware di entrambi i microcontrollori, mediante l’IDE, è stata sviluppata una specifica piattaforma Arduino dedicata alla programmazione della board.

Il processore ESP è programmabile esattamente come lo è il 328. È stato infatti rilasciato un Core Arduino dedicato che può essere reperito, assieme alla documentazione, sull’apposita pagina GITHUB e che da la possibilità agli utenti di personalizzare il comportamento del processore ESP sovrascrivendo quello impostato di fabbrica.

La scelta dell’antenna integrata è stata dettata dalla necessità di un compromesso tra efficienza e versatilità, a vantaggio della riduzione dell’ingombro; d’altra parte il modulo nasce per sperimentazione ed uso domestico, e non per scopi industriali.

Hardware del modulo Jolly

Come già detto, il modulo Jolly è caratterizzato dalla coesistenza di due microcontrollori su un PCB di forma e dimensioni praticamente identiche a quelle di un microcontrollore ATmega328P.

I due micro sono l’ESP8285H16, a sua volta costituito da un ESP8266 e da una memoria flash da 2 MB, e da un ATMEGA328PB-MU, quindi lo stesso microcontrollore presente sull’Arduino UNO, ma di costruzione più recente, caratterizzata non solo da un package di tipo QFN (che lo rende molto più compatto) ma anche dall’aggiunta della Porta E che offre GPIO aggiuntivi, anche se in questo caso non sono disponibili esternamente.

È presente inoltre un regolatore di tensione lineare CMOS da 3.3 V, il MIC5303-3.3, caratterizzato da un basso dropout (100 mV a 300 mA), una corrente massima garantita di 300 mA, elevata precisione e protezioni termica e da sovracorrente.

I due micro comunicano tra di loro usando l’interfaccia SPI esposta sulla Porta B, la stessa che viene portata all’esterno del modulo e usata dall’Arduino UNO sui pin 13, 12, 11; questa cosa impone un limite all’uso dell’SPI come periferica di comunicazione verso l’esterno del modulo quando il Wi-Fi è in funzione.

Invece i GPIO afferenti alla Porta E aggiuntiva vengono utilizzati per la sincronizzazione tra i due micro e ciò permette di non sacrificare i GPIO connessi ai connettori di I/O dell’Arduino UNO, mantenendo pertanto la piena compatibilità con l’ATmega328P.

Vediamo come vengono usati questi GPIO:

• ESP_SR (PE0): canale usato dall’ESP8285 per segnalare all’ATmega328PB che è pronto a comunicare;
• ESP_ON/OFF(PE1): canale usato dall’ATmega328PB per accendere e spegnere l’ESP8285;
• ESP_CS(PE2): canale usato dall’ATmega328PB per indirizzare la comunicazione SPI verso l’ESP8285 anziché verso l’esterno del modulo; chiaramente quando viene usato la comunicazione SPI esterna non è disponibile;
• ESP_BOOT(PE3): canale usato per mettere l’ESP8285 in modalità boot ed è controllato sia dall’ATmega328PB che dall’utente mediante il tasto di boot presente sulla scheda.

L’attivazione del boot dell’ESP8285 è mediata dal bootloader presente sull’ATmega328PB, che deriva dall’Optiboot presente nell’ATmega328P montato sull’Arduino UNO.

Per avviare la modalità di boot dell’ESP8285, l’Optiboot modificato resta “in ascolto” dell’attivazione del tasto di boot in successione ad un evento di reset. Come si può osservare nella (Fig. 5),

 

l’ATmega328PB in uscita dalla condizione di reset verifica lo stato di ESP_BOOT e se questo si trova a stato logico 0 mette l’ESP8285 in boot mode.

Vediamo ora l’utilizzo dei seguenti GPIO dell’ESP8285:

• SD_DATA2: serve per controllare il LED integrato, utile a segnalare l’attività della periferica Wi-Fi;
• GPIO4: serve per forzare il reset dell’ATmega328PB e permettere in futuro l’implementazione di un algoritmo di OTA.

Montaggio e utilizzo del modulo Jolly

Per poter utilizzare il modulo Jolly basterà togliere il chip ATmega328P, facendo leva delicatamente con un estrattore dedicato o un cacciavite a taglio tra il chip e lo zoccolo, facendo attenzione a non piegare i piedini del microcontrollore.

La scheda da noi testata è già priva dell’ATmega328P-PU originale, quindi occorrerà solo inserire il modulo, i cui pin sono lunghi e consistenti, quindi bisogna fare una certa pressione, ma è sufficiente che sia garantito il contatto, senza eccedere.

Per salvaguardare lo zoccolo della scheda se ne potrebbe aggiungere un altro identico, sul quale innestare il modulo, inserendo poi il tutto nella scheda.

Bisogna fare molta attenzione al verso di inserimento, orientandolo come in (Fig. 6), cioè con l’antenna rivolta verso l’esterno della board.

 

Installazione del modulo Jolly (Windows, Linux e macOS)

È richiesta la versione di Arduino IDE 1.8.13 o superiore, noi abbiamo usato la 1.8.19. I passaggi da seguire sono i seguenti:

• Selezionare il menu File – Impostazioni;
• Aggiungere i seguenti due link nel campo URL aggiuntive per il Gestore schede: https://tech-jollydev.github.io/package_jolly_index.json, https://espressif.github.io/arduino-esp32/package_esp32_index.json separandoli con una virgola;
• Dal menu Strumenti – Scheda selezionare l’opzione Gestore schede…;
• Digitando jolly nella barra di ricerca appare la scheda Jolly AVR Boards;
• Cliccare su Installa e quindi chiudere e riavviare l’IDE;
• Entrare nuovamente nel menu Strumenti – Scheda e selezionare la board jolly-dev • Jolly (Fig. 7).

 

Fig. 7 Configurazione del modulo Jolly nell’IDE.

Ricaricare il firmware predefinito dell’ESP8285

Nel caso in cui il firmware debba essere aggiornato per qualsiasi motivo, nel repository GitHub è disponibile una versione precompilata del firmware predefinito dell’ESP8285 e già caricato all’origine.

Esso è composto da due file: WiFiManager.bin e WiFiManager_spiff.bin.

Per l’eventuale aggiornamento bisogna seguire una specifica procedura:

• Nell’IDE Arduino selezionare il menu Strumenti; Scegliere ESP8285 per l’opzione bootloader, come mostrato in (Fig. 8);
• Premere e mantenere premuto il pulsante di boot situato sul modulo Jolly; premere il pulsante di reset sull’Arduino UNO per 1 secondo, quindi rilasciarlo; mantenere ancora premuto il pulsante di boot per un altro secondo, quindi rilasciarlo. A questo punto il Jolly è entrato in modalità di boot per l’ESP8285;
• Cliccare sull’opzione Scrivi il bootloader dal menu Strumenti e la procedura si avvierà automaticamente. Per tenere traccia del processo di aggiornamento, nelle Impostazioni attivare le due opzioni compilazione e caricamento del campo “Mostra un output dettagliato durante:”. Gli utenti più esperti hanno la possibilità di personalizzare completamente il codice in esecuzione sull’ESP8285 utilizzando la piattaforma dedicata disponibile a questo link: https://github.com/tech-jollydev/jolly-arduino-esp8285-platform.

Jolly Webpanel

Entriamo ora nel vivo dell’uso del modulo Jolly, che viene consegnato con lo sketch WiFiRestServer.ino precaricato.

Questo codice consente all’utente, mediante interfaccia WiFi, di accedere a una pagina web per il controllo remoto dei GPIO presenti sulla scheda.

Su questa pagina, che prende il nome di Webpanel, è possibile settare i pin digitali come INPUT e leggerne lo stato logico, oppure come OUTPUT, impostandoli sullo stato logico HIGH (1) o LOW (0); per quelli associati al PWM è possibile regolare il valore tramite un cursore; infine si può leggere il valore dei pin analogici.

Per accedere al Webpanel è necessario aprire, da PC o smartphone, l’elenco delle connessioni WiFi disponibili, cercare quella relativa alla scheda Jolly e collegarsi ad essa (Fig. 9).

 

Ora, tramite un browser, digitare l’indirizzo 192.168.240.1 (è prefissato in fabbrica ed è uguale per tutti i moduli), dopo qualche istante si aprirà la maschera visibile in (Fig. 10).

 

L’interfaccia è molto intuitiva, basta cliccare sul GPIO da controllare o monitorare, sull’immagine della scheda, e alla sua destra apparirà un riquadro per interagire col pin; nel nostro esempio abbiamo settato questi pin:

• Pin digitale 3 come OUTPUT con PWM a 95;
• Pin digitale 6 come INPUT, collegato ai 3,3 V della scheda;
• Pin digitale 8 come OUTPUT su ON;
• Pin analogico A0 collegato ai 3,3 V della scheda.

In (Fig. 11) riportiamo il circuito realizzato per le prove, avvalendoci di una breadboard e di quattro componenti esterni.

 

Mettiamo a confronto il circuito con le indicazioni del Webpanel:

• Il pin digitale 3 è usato come uscita PWM, il valore 95 fa accendere il LED con una luminosità ridotta;
• Il pin digitale 6 è settato come ingresso, essendo collegato ai 3,3 V di Arduino, cliccando sul pulsante Check si ottiene come risultato 1 (HIGH);
• Il pin digitale 8 è settato come uscita HIGH, quindi il LED ad esso collegato ha la massima luminosità;
• Il pin analogico A0 è collegato ai 3,3 V di Arduino, siccome il riferimento del convertitore analogico-digitale è 5 V (che corrisponde a 1023) cliccando sul pulsante Check la lettura è di 680.

In (Fig. 12) lo schema dei collegamenti per chi volesse replicare questo test.

 

Ora cerchiamo di comprendere il funzionamento del codice. Quello scritto per realizzare il web panel è formato da file in html, css e javascript.

Quest’ultimo si interfaccia ad una parte del firmware, scritto nel linguaggio di Arduino, che è in esecuzione sulla scheda.

Quando ci si collega alla scheda digitando sul browser l’indirizzo IP ad essa associato, i file html, css e javascript vengono trasmessi dalla scheda al browser.

Quest’ultimo li interpreta e genera l’interfaccia grafica del Webpanel. In pratica la scheda Arduino col modulo Jolly ha funzione di server, mentre il browser si comporterà da client comunicando con lo sketch caricato sul modulo Jolly (Fig. 13).

 

Ad ogni manovra effettuata sul Webpanel partirà una chiamata di tipo REST verso la scheda.

Prendiamo ad esempio il caso in cui l’utente prema il pulsante Check per leggere il pin analogico A0.

L’HTML sul client, corrispondente al pulsante, è il seguente:

<button id=”analog_0_but” onclick=”onckl(this)” class=” el_click but_check pure-button button-primary”>Check</button>

In questo frammento di codice è specificato che all’evento di click sul pulsante (onclick) deve essere richiamata la funzione javascript onckl.

La funzione javascript onckl, dopo aver effettuato i diversi controlli sull’operazione da eseguire, dipendente dal pulsante che è stato premuto, utilizzerà la funzione ajax per far partire una chiamata verso la scheda col modulo, in questo modo:

ajax(getUrl()+”/analog/”+relid[1], “analog_”+relid[1]+”_value”);

A questo punto il client invierà al server, in ascolto sulla scheda, una chiamata del tipo:
http://192.168.240.1:8080/jolly/analog/0

Sulla scheda è in esecuzione lo sketch WiFiRestServer.ino, precaricato sull’ATmega328PB. Esso si occupa di gestire tutte le interazioni che l’utente può fare con il webpanel.

Nel dettaglio, il codice dichiara un oggetto server in ascolto sulla porta 8080 e un oggetto client che rappresenta le chiamate ricevute in remoto sul server:

WiFiServer server(8080);
WiFiClient client;

Nel setup la scheda viene connessa ad internet e il server viene inizializzato (Listato 1 – server).

Nel loop la scheda resta in ascolto di richieste in arrivo dal client. Non appena arriva una richiesta, questa viene assegnata all’oggetto WiFiClient e viene processata (Listato 2 – server).

La funzione process analizza l’URL della richiesta per individuare il comando da eseguire (Listato 3 – server).

L’URL associato al comando nel nostro esempio corrisponde ad “analog”, quindi verrà richiamata la funzione analogCommand(), la quale analizza la parte finale dell’URL per individuare il pin associato alla richiesta e il tipo di operazione da effettuare.

In questo caso la parte finale dell’URL è ‘0’ che corrisponde al GPIO di cui vogliamo leggere il valore (A0). A questo punto viene richiamata la funzione analogRead() su quel pin e il risultato verrà restituito al client in esecuzione sul browser mediante la funzione client.print() (Listato 4 – server).

Arrivata la risposta al browser, questa verrà inserita come innerHTML dell’elemento associato alla richiesta. In questo modo sarà possibile vedere il risultato della funzione analogRead() nel browser (Listato 5 – client)

Sketch di esempio

Per poter testare i numerosi esempi forniti dal produttore, è necessario selezionare la scheda Jolly e aprire il menu File > Esempi.

Qui è presente la sezione “Esempi per Jolly” che contiene tutti gli sketch forniti con la scheda.

Per testare uno sketch, è necessario aprirlo nell’IDE, impostato come descritto in precedenza, e poi caricarlo nella scheda tramite il solito comando di UPLOAD (Carica).

Ovviamente, una volta caricato un nuovo sketch, l’originale WiFiRestServer viene sovrascritto e il Webpanel smette di funzionare.

Per ripristinare il funzionamento del Webpanel, è necessario caricare nuovamente lo sketch originale, che si trova nella cartella WiFi\esempi.

Collegare il modulo Jolly alla rete di casa

Un collegamento alternativo a quello visto finora, cioè tramite WiFi al modulo, consiste nel fornire al modulo l’SSID e la password della propria rete domestica.

La prima operazione da fare è caricare ed eseguire lo sketch ScanNetworks.ino, presente sempre nella cartella WiFi degli esempi e poi aprire il Monitor seriale impostando 115200 bps.

Verranno elencate tutte le reti riconosciute dal WiFi del modulo. Verificate la presenza della vostra rete ricordando che il modulo vede solo le reti a 2,4 GHz e non quelle a 5 GHz (Fig. 14).

 

A questo punto bisogna aprire lo sketch WiFiWebClient.ino, presente sempre nella stessa cartella, ed inserire i due parametri nelle rispettive righe:

char ssid[ ] = “NomeRete”; //your network SSID
char pass[ ] = “password”; // your network password

quindi si carica lo sketch nella scheda e si apre il Monitor seriale, sempre a 115200 bps.

Se va tutto bene dopo qualche istante si vedrà il messaggio di conferma del collegamento tra il Jolly e la rete domestica, con l’indirizzo IP assegnato (Fig. 15).

 

Una volta effettuato il collegamento, per ripristinare la modalità Webpanel occorre ricaricare nella scheda lo sketch WiFiRestServer.ino.

A questo punto il collegamento al Jolly potrà essere effettuato anche con l’IP assegnatogli dalla rete domestica, si aprirà il Webpanel e funzionerà allo stesso modo.

Bene, qui si conclude il test di questo eccellente modulo, che aggiorna Arduino UNO dotandolo della funzione WiFi, ed aprendolo al mondo dell’IoT, ci sentiamo di consigliarlo a chiunque intenda aggiornare i propri progetti o realizzarne di nuovi, in ambito domotico.