Usando YUN (almeno a me capita un po' troppo spesso) puo' succedere di perdere il controllo della porzione Linux che non risulta piu' raggiungibile via rete. Il factory reset ottenuto tramite la pressione per 30 secondi del tasto WLAN RST non mi ha mai funzionato
Un modo per correggere gli errori e ripristinare la rete (wifi od ethernet che sia) e' quello di connettere la YUN fisicamente con il cavo USB e montare lo sketch presente in Esempi/Bridge/YunSerialTerminal
A questo punto si apre il terminale seriale e si preme il pulsante di YUN RST (a fianco delle porte analogiche). Sul terminale seriale si vedranno scorrere i messaggi del boot Linux fino a conquistare una shell con cui poter interagire e rimettere a posto il lato software della scheda
Questa e' una piccola modifica al sistema di invio dati di SismoArduino
In alcuni casi puo' essere comodo non conoscere a priori l'indirizzo del server a cui inviare i dati ed essere comunque in grado di configurare la scheda Arduino
La soluzione e' quella di inviare i pacchetti UDP in modalita' broadcast. In questo modo tutte le macchine della rete ricevono il pacchetto; cio' genera ovviamente un traffico inutile sulla rete ma e' piu' o meno quello che fanno i computer Windows e nessuno si e' mai lamentato piu' di tanto per cui non mi farei problemi
Fonte Wikipedia
Lo sketch di invio deve solo modificare l'indirizzo del server con l'IP di broadcast che e' 255.255.255.255 (la versione 192.168.1.255 non funziona!!)
------------------------------------------- #include <SPI.h> #include <Ethernet.h> #include <EthernetUdp.h> //Arduino byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; IPAddress ip(192,168,1,2); unsigned int localPort = 8888; //Server byte remoteIP[4] = {255,255,255,255}; int remotePort = 5005; String dati; char charBuf[1024]; EthernetUDP Udp; void setup() { Serial.begin(115200); Ethernet.begin(mac,ip); Udp.begin(localPort); } void loop() { int x = analogRead(A5); delay(2); int y = analogRead(A4); delay(2); int z = analogRead(A3); dati = String(x)+","+String(y)+","+String(z); Serial.println(dati); dati.toCharArray(charBuf, 1024); Udp.beginPacket(remoteIP, remotePort); Udp.write(charBuf); Udp.endPacket(); delay(2); }
-------------------------------------------
il programma in Python che funziona da server deve essere invece riscritto per non ignorare i pacchetti broadcast
Per spingere ancora piu' al limite il passo di campionamento di Sismo YUN ho modificato lo sketch per ridurre al minimo di tempi tra le letture analogiche
Lo sketch e' il seguente (il ritardo e' passato da 10 millisecondi a 2 millisecondi). Tutta la rimanente configurazione e' la stessa dei precedenti post
------------------------------------------------ void setup() { delay(50000); Serial1.begin(115200); } void loop() { Serial1.print(millis()); Serial1.print(","); Serial1.print(analogRead(A3)); Serial1.print(","); delay(2); Serial1.print(analogRead(A4)); Serial1.print(","); delay(2); Serial1.println(analogRead(A5)); delay(2); }
------------------------------------------------
Con questo sistema la media e' stata di una acquisizione ogni 8 millisecondi (circa 142 Hz)
Si osserva chiaramente il miglioramento della forma d'onda rispetto alle acquisizioni a passi di campionamento piu' lenti
Non contento del passo di campionamento ottenuto nel precedente post ho provato a migliorare le prestazioni svincolandomi dalla libreria Bridge
SismoYUN in questo caso alimentata da un comune PowerBank da 1000 mA
Il suggerimento mi e' venuto leggendo questo post. In pratica Linux puo' leggere i dati di Arduino, Arduino li puo' spedire sulla Serial1 e Linux li puo' leggere su /dev/ttyATH0. Per fare cio' si deve pero' modificare il file /etc/inittab commentando la linea che setta questa porta seriale e riavviando
questo e' lo sketch Arduino
e' fondamentale la riga in giallo. Se Arduino inizi a sparare dati sulla seriale a Linux mentre questo e' in fase di boot, il boot stesso si blocca in modo irrecuperabile (limite di 50 secondi prima di iniziare ad inviare dati)!!!!
-------------------------------------------- void setup() { delay(50000); Serial1.begin(115200); } void loop() { Serial1.print(millis()); Serial1.print(","); Serial1.print(analogRead(A3)); Serial1.print(","); delay(10); Serial1.print(analogRead(A4)); Serial1.print(","); delay(10); Serial1.println(analogRead(A5)); delay(10); }
--------------------------------------------
per la parte Linux i dati sulla seriale li ho letti con Python. Per fare cio' ho usato la libreria Python Serial che non e' disponibile mediante opkg ma deve essere installata manualmente con il setup normale di Python
i dati passati sono il tempo in millisecondi e poi i tre valori di accelerazione. Questi vengono salvati sulla sdcard
--------------------------------------------
#!/usr/bin/python
import serial
ser = serial.Serial('/dev/ttyATH0',115200)
out_file = open("/mnt/sda1/dati_veloci.txt","w")
while True:
lettura = ser.readline()
out_file.write(lettura)
--------------------------------------------
Con queste impostazioni i dati vengono registrati e salvati alla velocita' di circa 30 Hz. Forse passando ad una SdCard di classe 10 (o piu' veloci) le cose possono ancora migliorare ma gia' cosi' il miglioramento e' significativo
Per la presentazione dei dati a Web e' stato utilizzato il sistema precedente modificando leggermente gli script
Il tentativo di SismoArduino mi e' piaciuto ma volevo vedere se si riusciva ad integrare tutto dentro ad un solo controllore ovvero acquisizione dati e presentazione dati.
Cosi' e' nata SismoYUN
Come visto nel precedente post e' piuttosto lento scambiare i dati dalla parte Arduino (quella deputata alla acquisizione del dato) a quella di presentazione del dato di Linux; per questo motivo ho cercato un escamotage ovvero di salvare i dati sulla scheda SD dallo sketch di Arduino per poi recuperarli in PHP
I dati per motivi di spazio sono salvati sulla scheda SD
-------------------------------------------------------------- #include <FileIO.h> void setup() { Bridge.begin(); Serial.begin(9600); FileSystem.begin(); } void loop() { char buf[50]; File dataFile = FileSystem.open("/mnt/sda1/datalog.txt",FILE_APPEND); unsigned long tempo = millis(); sprintf(buf,"%lu",tempo); dataFile.print(tempo); dataFile.print(","); dataFile.print(analogRead(A3)); dataFile.print(","); dataFile.print(analogRead(A4)); dataFile.print(","); dataFile.println(analogRead(A5)); delay(2); }
--------------------------------------------------------------
La velocita' di scrittura sulla SD e' diciamo pessima. Ogni ciclo di scrittura impiega 150 ms (6.6Hz) :<<
ma dato e' poco piu' di un test facciamo finta che vada bene
Per la parte Linux ho configurato il webserver con PHP5 come indicato nel predecente post ed ho usato la libreria DyGraph per plottare i dati
Lo script in PHP recupera le ultime 100 linee del file di datalog.txt e crea un csv
-------------------------------------------------------------- <?php function tailShell($filepath, $lines = 1) { ob_start(); passthru('tail -' . $lines . ' ' . escapeshellarg($filepath)); return trim(ob_get_clean()); } header('Content-Type: text/csv; charset=utf-8'); $output = fopen('php://output','w'); $dati = tailShell("/mnt/sda1/datalog.txt",100); $dati2 = str_replace(" ","\r\n",$dati); fputs($output,$dati2); ?>
Considerando che tutto gira su una schedina che sta nel palmo di una manno (connessione Wifi e wired incluse) con un server web completo e che fa acquisizione realtime non e' proprio male
Sulla YUN vivono in coabitazione due anime, la parte Arduino e la parte Linux.
L'interfaccia naturale per scambiarsi i dati e' un servizio REST
Sullo sketch, mediante la libreria Bridge, si carica una variabile in valore (nell'esempio la variabile e' A3 ed il suo contenuto e' il valore della porta analogica A33)
