![\"Totem\"](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/1.jpg\")
<\/a>Era da tempo che cercavo un progettino sul quale cimentarmi con il mio arduino yun<\/a>, uno di quelli che mi impegnasse almeno pi\u00f9 di un giorno, quando, camminando per Roma, mi sono imbattuto in uno di questi pannelli. L\u2019Atac<\/a> che \u00e8 l\u2019agenzia della mobilit\u00e0 romana, ha da qualche tempo installato alcuni di questi pannelli in giro per la citt\u00e0. La loro funzione (usando il condizionale) sarebbe quella di informare gli utenti di bus e tram degli orari di arrivo per una determinata fermata o banchina. Una cosa molto utile soprattutto per i turisti che, magari, non possono usare le utili applicazioni per smartphone che come il pannello forniscono le stesse informazioni. Fra le varie applicazioni e servizi che offrono questo tipo di informazioni c\u2019\u00e8 il sito: muovi.roma<\/a> , che non \u00e8 altro che una versione pi\u00f9 accessibile del sito Atac. Fra i vari link presenti su quella pagina non mi sono fatto sfuggire questo: ![\"Atac](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/2.png\")
<\/a>Che mi ha portato alla pagina del progetto Atac Open Data<\/span><\/a>.<\/span><\/span> Con Enorme Sorpresa ho quindi scoperto che l\u2019Atac ha realizzato una serie di strumenti ed api<\/span><\/a>, completamente gratuite ed open source<\/span><\/a>,<\/span><\/span> per interfacciarsi con il sistema di trasporto romano.<\/p>\nNavigando sul sito del progetto e spulciando fra la documentazione delle varie api, ho trovato quello che faceva al caso mio: l\u2019api \u201c paline.Previsioni<\/span><\/a> \u201d con relativo esempio di utilizzo<\/span><\/a>. Questa non fa altro che prendere in input un numero palina (La fermata che volete monitorare) e restituire una struttura dati<\/span><\/a> contenente gli arrivi e la lista delle linee che passano per quella fermata, o palina. Avendo quindi trovato il dove (prendere le previsioni), non restava altro che pensare al come.<\/p>\n L\u2019architettura: L\u2019Hardware:<\/strong><\/p>\n Preparativi:<\/strong><\/p>\n Prima di cominciare a smanettare con il codice, se non l\u2019avete gi\u00e0 fatto vi consiglio di fare un paio di cose al vostro yun:<\/p>\n Ancora pi\u00f9 importante \u00e8 avere un ambiente di lavoro il pi\u00f9 produttivo possibile, che vi permetta di scrivere il codice nel migliore dei modi. Dato che yun \u00e8 sprovvisto di un\u2019interfaccia grafica, il pi\u00f9 classico dei modi per il mondo Unix\/Linux \u00e8 l\u2019uso di un text editor come VI<\/span><\/a> o nano<\/span><\/a>. Fra i due, quello che uso da anni \u00e8 nano, che per qualche arcano motivo sullo yun non voleva partire, fino a quando non ho aggiunto al sistema questa variabile d\u2019ambiente con il comando:<\/p>\n echo \u201cexport TERM=xterm\u201d >> \/etc\/profile.<\/em><\/p><\/blockquote>\n Fatto ci\u00f2, c\u2019\u00e8 da dire che fa comodo avere un editor testuale da usare direttamente nella shell ma nel 2015 ci sono altre possibilit\u00e0, come ad esempio la condivisione dei file con un computer dove \u00e8 installato un editor di testo grafico(che magari abbia funzioni pi\u00f9 avanzate di quelle di nano e VI). Tra i protocolli di condivisione file pi\u00f9 usati ci sono NFS<\/span><\/a>; SFTP\/SCP<\/span><\/a> e Samba<\/span><\/a>,<\/span><\/span> ma forse quello pi\u00f9 utilizzato \u00e8 Samba<\/span><\/a>, che non \u00e8 altro che l\u2019implementazione Open Source della condivisione file di Windows. Installandolo sul vostro Yun potrete accedere e modificare i file del vostro Arduino Yun direttamente sul vostro pc, sia esso Linux, Windows o Mac. Se vi interessa potete dare uno sguardo a questo breve tutorial<\/span><\/a>.<\/p>\n Lo script python:<\/strong><\/p>\n Bene, siamo quasi pronti per la nostra prima richiesta che, come detto in precedenza, far\u00e0 uso del codice fornito nell\u2019esempio<\/a> presente sul sito open bus. Ma prima di ci\u00f2 parliamo di un paio di cose:<\/p>\n Detto ci\u00f2, passiamo ai fatti. Atac fornisce un semplice esempio di utilizzo delle api<\/span><\/a>, ma se non avete mai sentito parlare di python vi consiglio di leggere o guardare uno dei tantissimi tutorial che affollano la rete, cos\u00ec da avere un\u2019infarinatura generale. Per accedere alle api bisogna prima registrarsi<\/span><\/a> come indicato nella pagina del progetto Open Data, dopo questa formalit\u00e0 si \u00e8 pronti per cominciare creando il primo script python:<\/p>\n Una volta creato il file e, dopo aver inserito la chiave ottenuta dal modulo di registrazione, baster\u00e0 digitare \u201cpython nomefile.py<\/em>\u201d per avviare lo script appena creato. Come output avremo il \u201cpprint<\/em>\u201d della risposta, ma cos\u2019\u00e8 \u201cpprint<\/a>\u201d ? E\u2019 un modulo python usato per \u201cstampare\u201d il contenuto di una struttura dati in maniera pi\u00f9 accattivante. Se la risposta fosse troppo grande da essere visualizzata nel vostro terminale, potete effettuare un redirect<\/a> verso un file con: \u201cpython nomefile.py > output.txt<\/em>\u201d: in questa maniera l\u2019output del vostro script python viene scritto in un file di testo chiamato \u201coutput.txt\u201d.<\/p>\n Analizzando il contenuto della risposta, troveremo le previsioni di arrivo per la nostra palina nel formato descritto nella pagina di documentazione dell\u2019api<\/a>, ma come avete potuto vedere l\u2019output contiene una rappresentazione degli arrivi che non pu\u00f2 essere ancora utilizzata per il nostro scopo. Abbiamo quindi bisogno di selezionare e formattare quello che ci interessa, e di parametrizzare lo script, cio\u00e8 trovare un modo per cambiare il numero palina dinamicamente, senza mettere mano allo script. Per la parametrizzazione, possiamo semplicemente prendere il numero palina e la chiave come parametri del nostro script. Aprendo il file \u201catac.py\u201d dalla cartella \u201cpalina\u201d del codice sorgente, possiamo quindi vedere che con l\u2019istruzione \u201cNUMERO_PALINA = str(sys.argv[2])<\/em>\u201d assegniamo il valore del secondo parametro di linea di comando alla variabile numero palina.<\/p>\n Per la selezione, invece, basta scorrere la lista \u201cprimi per palina\u201d con un ciclo \u201cfor<\/a>\u201d e selezionare con una serie di \u201cif<\/a>\u201d gli arrivi con le propriet\u00e0 che pi\u00f9 ci interessano, per esempio non visualizzando gli arrivi delle linee non monitorate o quelle per le quali non \u00e8 previsto nessun arrivo. Dato il piccolo display a nostra disposizione dobbiamo rendere l\u2019output del nostro script pi\u00f9 leggibile: per fare ci\u00f2 eliminiamo i caratteri come le parentesi, e riduciamo parole come capolinea in \u201cCapol\u201d e fermate in \u201cFerm\u201d, facendo delle piccole sostituzioni<\/a> – es: \u201d.replace(“Capolinea”, “Capol”)<\/em>\u201d.<\/em> Eseguendo lo script dalla riga di comando con \u201cpython atatc.py chiave_atac numero_fermata<\/em>\u201d avremo il seguente output: Che verr\u00e0 poi visualizzato sul display cos\u00ec:<\/p>\n Per rendere il tutto pi\u00f9 solido possiamo anche aggiungere dei blocchi \u201ctry, except<\/span><\/a>\u201d per una corretta gestione delle eccezioni<\/span><\/a>, in modo da non vedere \u201cesplodere\u201d il nostro script al primo problema.<\/p>\n Il demone Linux:<\/strong><\/p>\n Per il controllo dello script python ho deciso di utilizzare un demone linux<\/a> (che non ha nulla a che vedere con i Black Sabbath). In un sistema Unix\/Linux, un demone \u00e8 un programma o servizio che viene eseguito in background. Di norma un demone viene lanciato all\u2019avvio della macchina dal processo init<\/a>, che \u00e8 il primo processo ad essere eseguito dal kernel<\/a> dopo il bootstrap<\/a>. Solitamente un demone \u00e8 composto da due parti:<\/p>\n Per approfondire l\u2019argomento vi consiglio di leggere uno dei tanti tutorial presenti in rete, tra i quali per Linino\/Openwrt vi consiglio la nota tecnica<\/span><\/a> presente sul sito ufficiale di Openwrt.<\/p>\n \u00a0Aprendo il file \u201c\/etc\/init.d\/pallina\u201d contenuto nell\u2019archivio del codice sorgente potrete vedere la mia implementazione dello script di controllo. Il codice \u00e8 commentato e dovrebbe essere di facile comprensione, l\u2019unica parte degna di nota \u00e8 forse il blocco \u201creload\u201d, nel quale dopo aver controllato che l\u2019eseguibile sia in esecuzione, invio il segnale<\/span><\/a> SIGUSR1. Questo segnale \u00e8 un segnale \u201cUser defined\u201d al quale si pu\u00f2 dare il significato che si vuole, nel mio caso lo uso per ordinare al programma ricevente di ricaricare le impostazioni dal file.<\/p>\n Veniamo ora al corpo del demone: il file \u201c\/root\/pallina\/pallinad\u201d il quale \u00e8 scritto in bash<\/span><\/a> (uno dei linguaggi di scripting pi\u00f9 usati al mondo). Linino non ha bash pre installato perch\u00e9 su openwrt la shell di default \u00e8 ash, per installare bash dovete eseguire i seguenti comandi: \u201copkg update; opkg install bash\u201d.<\/p>\n Lo script parte chiamando la routine \u201cloadSettings\u201d la quale carica i parametri dal file \u201csettings.ini\u201d, in questo file sono troviamo: il numero palina da monitorare, la chiave atac e il numero di secondi da attendere prima di una nuova richiesta.<\/p>\n Il secondo step e dichiarare due Traps<\/span><\/a>:<\/p>\n A questo punto informiamo il mondo dell\u2019avvio del demone in due modi:<\/p>\n Siamo ora nel vivo del codice. Dopo aver verificato che il parametro \u201cTIMER\u201d sia maggiore di 10 secondi(per evitare di bombardare il server con troppe richieste), siamo pronti per far partire il while che serve a creare il timer delle richieste. Fino a quando la variabile \u201cTIMER_ENABLED\u201d ha valore \u201cTRUE\u201d eseguiremo un semplice ciclo nel quale richiederemo le previsioni con la chiamata alla routine \u201caggiorna\u201d, per poi dormire per un numero di secondi uguale della variabile \u201cTIMER\u201d.<\/p>\n Perch\u00e9 ho creato un ciclo che dorme (istruzione sleep) per un solo secondo alla volta, anzich\u00e9 dormire con unica istruzione per un numero di secondi pari al valore della variabile \u201cTIMER\u201d ? Ve lo spiego con un esempio: se sospendessimo l\u2019esecuzione per 15 secondi non avremmo la possibilit\u00e0 di ricevere nessun segnale dal sistema operativo per tutta la durata di questo tempo, cosa che renderebbe il nostro codice poco efficiente. Con il ciclo, invece, dormiamo per un solo secondo alla volta, processando le eventuali richieste dell\u2019OS in tempo per dare un feedback all\u2019utente.<\/p>\n Nella routine \u201caggiorna\u201d dopo aver controllato che tutti i parametri necessari abbiano un valore, passiamo all\u2019azione con questa istruzione: \u201c$DOWNLOADER $CHIAVE_ATAC $NUMEROPALINA > \/tmp\/tmp.txt 2>&1\u201d. Chiamiamo lo script python, che \u00e8 rappresentato dalla variabile \u201cDOWNLOADER=”python \/root\/pallina\/atac.py\u201d\u201d inviandogli i due parametri \u201c$CHIAVE_ATAC\u201d e \u201c$NUMEROPALINA\u201d, riversando l\u2019output nel file \u201ctmp.txt\u201d e non nel file \u201cultima.txt\u201d. Questo perch\u00e9, dobbiamo prima verificare che l\u2019output che vogliamo inviare al display contenga le previsioni della palina richiesta senza nessun errore, se tutto \u00e8 apposto possiamo versare il contenuto del file \u201ctmp.txt\u201d nel file \u201cultima.txt\u201d, aggiungendo quella strana sequenza di caratteri segnalati prima: \u201c#*#\u201d. Lo scopo di questa stringa \u00e8 quello di dichiarare che la scrittura del file \u00e8 terminata, in modo da evitare che sia Arduino che l\u2019interfaccia php leggano un file non completo. Questo perch\u00e9 ogni parte di questo progetto (Arduino, demone, interfaccia php) lavora in maniera asincrona.<\/p>\n L\u2019interfaccia web:<\/strong><\/p>\n Come ben sappiamo, la cosa che rende Arduino Yun diverso da i suoi fratelli Uno<\/a> e Leonardo<\/a>, sta nel fatto che Yun oltre ad essere un microcontrollore programmabile \u00e8 anche un piccolo computer Linux che pu\u00f2 fare affidamento su un vasto se non illimitato parco software fatto da: librerie, interpreti, server web ecc … estendendo di fatto le potenzialit\u00e0 della piattaforma Arduino. Fra questi c\u2019\u00e8 php<\/a>, un linguaggio di scripting lato server<\/a> che, ad oggi, viene usato da milioni di sviluppatori per rendere i loro siti web dinamici.<\/p>\n Data questa possibilit\u00e0 ho deciso di realizzare un\u2019interfaccia web php, le cui funzioni sono:<\/p>\n L’interfaccia web<\/p><\/div>\n Per installare php sul vostro yun seguite questi semplici passi:<\/p>\n I file che compongono l\u2019interfaccia si trovano nella cartella \u201c\/www\/sd\/\u201d. Il file \u201cmain.php\u201d \u00e8 la parte principale di questa interfaccia. La pagina \u00e8 composta da una tabella che contiene cinque righe, le quali contengono:<\/p>\n Per aggiornare le varie parti della pagina senza ricaricare la pagina stessa, uso jQuery<\/a>, un potentissimo framework gratuito basato su javascript<\/a> che con poche righe di codice vi permette di dotare di effetti dinamici le vostre pagine web.<\/p>\n Il resto dei file previa lettura dovrebbe essere di facile comprensione. Se avete dubbi o non riuscite a capire parte del codice, lasciate un commento a fine articolo, tempo permettendo cercher\u00f2 di rispondervi.<\/p>\n Lo Sketch Arduino:<\/strong><\/p>\n In tutti o quasi i miei progetti troverete l’uso del watchdog<\/a> e di un led di stato, questo perch\u00e9 il watchdog aumenta l\u2019affidabilit\u00e0 del software, e il led di stato informa l\u2019utente della vitalit\u00e0 del sistema. In un sistema di controllo lo scopo del watchdog \u00e8 quello di resettare il microprocessore\\microcontrollore se questo non risponde ad uno stimolo entro una deadline<\/a> (Intervallo di tempo) configurabile. Il microcontrollore del nostro Arduino Yun (che \u00e8 un ATmega32u4<\/a>) \u00e8 dotato anche di un watchdog configurabile, che pu\u00f2 arrivare ad una deadline massima di 8 secondi.<\/p>\n Su Arduino l’accesso alle funzionalit\u00e0 del watchdog avviene grazie alla libreria “avr\/wdt.h<\/a>“, che ha sostanzialmente tre routine:<\/p>\n Se guardate il blocco setup<\/a> (quello eseguito all’avvio dello schetch) del file “yunlcd.ino\u201d, potrete vedere che la prima cosa che faccio \u00e8 quella di disabilitare il watchdog (nel caso fosse rimasto attivo dall’ultimo reset), eseguo poi tutte le operazioni necessarie all’avvio dello schetch e, prima di passare alla routine loop<\/a>, abilito il watchdog con una deadline di 4 secondi. Questo far\u00e0 si che se per un tempo maggiore di 4 secondi NON resetto il watchdog, questo resetter\u00e0 il Microcontrollore dello yun. La lunghezza della deadline dipende dal tipo di applicazione che state realizzando, ma su questo argomento si sono dibattuti in tanti, quindi non vado oltre poich\u00e8 ne potremmo parlare per giorni, se non per mesi. Se ne siete interessati, la rete ha tutte le risposte che cercate. Se avete seguito il mio discorso, avrete anche capito che da questo momento non potete interrompere il flusso di esecuzione con l\u2019istruzione delay<\/a> per pi\u00f9 di quattro secondi, a meno che non vogliate forzatamente resettare il vostro Arduino. Quindi, cosa si pu\u00f2 fare in questo caso? Semplice, si pu\u00f2 dividere il tempo per il quale si deve \u201cdormire\u201d in piccoli time slice<\/a> (termine preso in prestito dai sistemi in time sharing<\/a>) e al termine di ognuno di questi si pu\u00f2 resettare il watchdog, fino ad arrivare ad una somma di time slice uguale al tempo per il quale vogliamo dormire. Questo si vede nella routine wdDelay nel file “yunlcd.ino\u201d:<\/p>\n Il resto del codice si concentra sulla scrittura nel display del contenuto del file \u201c\/pallina\/ultima.txt\u201cche come sappiamo contiene le previsioni di arrivo. Il display che ho deciso di utilizzare in questo progetto \u00e8 un 4 righe per 20 caratteri di tipo seriale (LCM1602 IIC V1). Questo tipo di display si controlla con solo 2 cavi e con un costo leggermente superiore a quello dei display paralleli vi permette di perdere meno tempo nei collegamenti, e lascia liberi alle vostre esigenze gli altri pin di input\/output. La libreria che vi permette di interfacciarvi con questo tipo di display \u00e8 la \u201cLiquidCrystal_I2C\u201d, che potete trovare a questo indirizzo<\/span><\/a>, con relativi esempi di utilizzo. Credo che il resto del codice accompagnato dai relativi commenti sia di facile comprensione, l\u2019unica cosa che potrebbe darvi noia, se non l\u2019avete vista prima, \u00e8 la coda<\/span><\/a> \u201cQueueList <String> queue;\u201d che uso per memorizzare le righe contenute nel file delle previsioni. In generale una struttura dati \u00e8 un modo per rappresentare dei dati in un computer, sono esempi di strutture dati: le variabili, gli array(vettori) e le code. Le code<\/span><\/a> sono strutture dati di tipo FIFO<\/span><\/a>, il primo dato ad essere inserito(con l\u2019operazione push) \u00e8 anche il primo ad essere estratto(con l\u2019operazione pop). In Arduino le code si implementano con la classe<\/span><\/a> \u201cQueueList\u201d che potete trovare qui<\/span><\/a>, nel mio esempio questa contiene delle stringhe ma pu\u00f2 contenere qualsiasi tipo di dato. Come detto in precedenza se avete dubbi o non riuscite a capire parte del codice, lasciate un commento a fine articolo, tempo permettendo cercher\u00f2 di rispondervi.<\/p>\n Conclusioni:<\/strong><\/p>\n Lo scopo che mi ero preposto in questo primo articolo era quello di mostrare Arduino Yun nel pieno della sua potenza, con un esempio pratico che mostrasse la parte Linux al fianco di quella classica. Un fattore che credo non debba essere sottovalutato quando si sviluppa con Arduino Yun \u00e8 la portabilit\u00e0 del codice<\/a> che con poche modifiche pu\u00f2 girare su qualsiasi piattaforma Linux, rendendo Arduino Yun una economica piattaforma di apprendimento, oltre che un potente strumento per lo sviluppo delle proprie idee. Spero che sia l\u2019articolo che il codice allegato<\/a> (che \u00e8 sotto licenza GNU GPL V2<\/a>) possa esservi d\u2019aiuto o spunto, se avete domande, commenti o idee non esitate a postarle.<\/p>\n Alla prossima.<\/p>\n","protected":false},"excerpt":{"rendered":" Era da tempo che cercavo un progettino sul quale cimentarmi con il mio arduino yun, uno di quelli che mi impegnasse almeno pi\u00f9 di un giorno, quando, camminando per Roma, mi sono imbattuto in uno di questi pannelli. L\u2019Atac … Continua a leggere![\"Schema\"](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/schema.png\")
<\/a><\/strong><\/p>\n\n
\n
\n
\n
\n
\n
![\"Esempio](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/3-1024x742.png\")
<\/a><\/p>\n![\"Output](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/4.png\")
<\/a><\/p>\n
\n![\"Output\"](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/5.png\")
<\/a><\/p>\n![\"Output](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/6.jpg\")
<\/a><\/p>\n\n
\n
\n
\n
![\"Interfaccia\"](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/6.png\")
<\/a>\n
\n
![\"main.php\"](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/8.png\")
<\/a>In questo piccolo esempio tratto da \u201cmain.php\u201d definisco due funzioni:<\/p>\n\n
\n
![\"Sketch](\"http:\/\/www.prioprio.it\/wordpress\/wp-content\/uploads\/2015\/02\/7.png\")
<\/a>Dove ho anche aggiunto la funzionalit\u00e0 del led di stato, con la routine \u201cled()\u201d che come prima cosa resetta il watchdog e, se necessario, cambia lo stato del led da accesso a spento con una frequenza definita nella variabile \u201cnextLedTick\u201d. Se dopo aver letto il codice avete ancora le idee confuse sulla multiprogrammazione<\/span><\/a> con Arduino, vi consiglio di leggere questo tutorial<\/span><\/a> che vi spiegher\u00e0 come far lampeggiare un led senza l\u2019uso del classico delay.<\/p>\n