mercoledì 28 gennaio 2015

Installare client OpenVPN (Windows,Linux,Mac,IOS)

In questo post viene indicato come configurare i client OpenVPN su varia piattaforme
Si parte avendo disponibili i file client.crt, client.key, ca.crt e config.ovpn tutti nella stessa directory

Sui dispositivi desktop sono necessari i privilegi di amministratore perche' di fatto viene creata una interfaccia di rete virtuale

Linux

da linea di comando

openvpn --config file.ovpn

in Ubuntu c'e' anche una procedura guidata visuale dal menu delle connessioni di rete /VPN

MAC (Tunnelblick)

Si clicca sul file ovpn



Viene richiesto di aggiungere la chiave a Tunnelblick (richiesta anche la password)
Per connettersi basta cliccare sull'icona di Tunnelblick e selezionare la VPN desiderata



IOS (Client OpenVPN)
Tramite Itunes si seleziona il dispositivo, poi il tab App, si scorre verso il basso in Condivisione File e si aggiungono tutti e quattro i file


sul telefono verra' riconosciuta la nuova configurazione, Si clicca il pulsante + verde per aggiungerla




A questo punto con il pulsante a slitta si lancia la connessione


Windows (Client OpenVPN)
Si scarica il client da questo link e si copiano i quattro file  in C:\Programmi\OpenVPN\config

Si apre quindi OpenVPN GUI 
Appare un'icona nella traybar. Si clicca destro e connetti




martedì 27 gennaio 2015

VPN SSL con Zywall USG 20W

Lo Zywall USG 20 W e' un router wifi con alcune funzionalita' avanzate con la possibilita' di creare un server VPN su SSL o IPSEC dal costo non proprio trascurabile (e' circa sui 200 euro)

In questo post viene descritto come configurare la VPN su SSL su client Mac e Windows (ho provato con Linux ma senza risultati, non ho provato con la configurazione IPSEC...e' una macchina in produzione e dislocata in remoto su cui non e' possibile giocare piu' di tanto)

Ci si logga dalla finestra di amministrazione


Andando sul menu' di sinistra si clicca su Configuratione (i due ingranaggi gialli) e si sceglie VPN/SSL

Si crea un nuovo Object/User-Group e si inseriscono le credenziali di accesso

Si puo' quindi creare un oggetto Application ovvero il servizio a cui l'utente si logga (tipicamente un desktop remoto)
Si aggiunge quindi l'utente alla lista degli utenti che hanno accesso (Selected Users)


Si modifica quindi l'SSL_POOL ovvero il set di indirizzi della VPN

a questo punto e' finita la configurazione server e si passa al lato client

Per Windows la cosa e' banale in quanto da dentro Internet Explorer ci si collega all'indirizzo pubblico del router, si inseriscono le credenziali e si preme il pulsante SSL VPN. In automatico e' mandato in esecuzione un programma definito SecuExtender che permette di accedere al rete interna

Su Mac non esiste questo automatismo ed e' necessario scaricare il file da questo link ed avviarlo a mano

lunedì 26 gennaio 2015

VPN con WRT54GL e TomatoUSB


Perche' comprarsi un router wireless Linksys WRT54GL del 2005?
Perche' oramai con un costo moderato (inferiore ai 50 euro) si ottiene un hardware di tutto rispetto e un supporto hardware notevole visto il successo all'uscita (usa un firmware basato su Linux ed e' stato subito oggetto di vari hack per estenderne le possibilita' )


In questo senso esistono i progetti DD-WRT e Tomato che aggiungono funzionalita' di VPN
Visto che gli aggiornamenti di DD-WRT risalgono al 2009 mentre Tomato e' stato attivo fino almeno 2012 ho scelto di provare Tomato

La schermata di configurazione di WRT54GL con il firmware standard si trova all'indirizzo 192.168.1.1 (username: admin, password:admin)


Per aggiornare il firmware si scarica il file Tomato_1_28 decomprimendolo. Si va quindi in Administration/Firmware Upgrade e si effettua l'upload di WRT54G_WRT54GL.bin

Al riavvio la macchina riparte con il nuovo firmware


Con il firmware base non e' disponibile la funzionalita' OpenVPN. Si deve scaricare una versione modificata di Tomato (detta TomatoUSB). Si effettua quindi l'upload del file tomato-NDUSB-1.28.8754-vpn3.6.bin, nuovo riavvio ed e' terminato il lavoro di cambio di firmware

Si configura la porta WAN e il server del tempo (OpenVPN rifiuta i certificati se non e' impostato l'orario in modo corretto). Per poter vedere l'interfaccia di amministrazione dalla WAN deve essere flaggata l'apposita opzione (scelta sconsigliata ma in emergenza puo' essere utile)

a questo punto si entra in VPN Tunneling e si fa lo start del servizio



si arriva quindi alla configurazione dei certificati
Questa fase e' simile per Mac, Windows e Linux. In questo caso viene mostrato il caso Mac mediante l'uso del client TunnelBlick

Il programma, una volta lanciato, mette un'icona nell'angolo vicino all'orologio
Si clicca Dettagli VPN/Utilita'/Apri easy-rsa nel terminale

Per creare i certificati si usa la seguente sequenza di comandi
$ source ./vars
$ ./clean-all
$ ./build-ca
$ ./build-key-server server
$ ./build-key client1
$ ./build-dh

su Yosemite e' necessario anche cambiare le impostazioni avanzate come nell'immagine

a questo punto si aprono i file con editor di testo e si copia il contenuto nella schermata dell'amministrazione web del routert

BoxFile
Certificate Authorityca.crt
Server Certificateserver.crt
Server Keyserver.key
Diffie Hellman parametersdh1024.pem




Di nuovo si avvia il servizio ed il risultato dovrebbe essere qualcosa di questo tipo


Finita la configurazione del server si passa al lato client

si copiano i file 
ca.crt 
client1.crt
client1.key

in una directory e di crea una file nome_vpn.ovpn e con un editor di testo si incolla questo testo
(modificare la parte evidenziata in giallo con l'ip del router vpn)

--------------------------------------------------
##############################################
# Sample client-side OpenVPN 2.0 config file #
# for connecting to multi-client server.     #
#                                            #
# This configuration can be used by multiple #
# clients, however each client should have   #
# its own cert and key files.                #
#                                            #
# On Windows, you might want to rename this  #
# file so it has a .ovpn extension           #
##############################################

# Specify that we are a client and that we
# will be pulling certain config file directives
# from the server.
client
ns-cert-type server

# Use the same setting as you are using on
# the server.
# On most systems, the VPN will not function
# unless you partially or fully disable
# the firewall for the TUN/TAP interface.
;dev tap
dev tun21

# Windows needs the TAP-Win32 adapter name
# from the Network Connections panel
# if you have more than one.  On XP SP2,
# you may need to disable the firewall
# for the TAP adapter.
;dev-node MyTap

# Are we connecting to a TCP or
# UDP server?  Use the same setting as
# on the server.
;proto tcp
proto udp

# The hostname/IP and port of the server.
# You can have multiple remote entries
# to load balance between the servers.
remote xxxxxxxxx 1194

# Choose a random host from the remote
# list for load-balancing.  Otherwise
# try hosts in the order specified.
;remote-random

# Keep trying indefinitely to resolve the
# host name of the OpenVPN server.  Very useful
# on machines which are not permanently connected
# to the internet such as laptops.
resolv-retry infinite

# Most clients don't need to bind to
# a specific local port number.
nobind

# Downgrade privileges after initialization (non-Windows only)
;user nobody
;group nobody

persist-key
persist-tun
float

# If you are connecting through an
# HTTP proxy to reach the actual OpenVPN
# server, put the proxy server/IP and
# port number here.  See the man page
# if your proxy server requires
# authentication.
;http-proxy-retry # retry on connection failures
;http-proxy [proxy server] [proxy port #]

# Wireless networks often produce a lot
# of duplicate packets.  Set this flag
# to silence duplicate packet warnings.
;mute-replay-warnings

# SSL/TLS parms.
# See the server config file for more
# description.  It's best to use
# a separate .crt/.key file pair
# for each client.  A single ca
# file can be used for all clients.
ca ca.crt
cert client1.crt
key client1.key

# Verify server certificate by checking
# that the certicate has the nsCertType
# field set to "server".  This is an
# important precaution to protect against
# a potential attack discussed here:
#  http://openvpn.net/howto.html#mitm
#
# To use this feature, you will need to generate
# your server certificates with the nsCertType
# field set to "server".  The build-key-server
# script in the easy-rsa folder will do this.
;ns-cert-type server

# If a tls-auth key is used on the server
# then every client must also have the key.
;tls-auth ta.key 1

# Select a cryptographic cipher.
# If the cipher option is used on the server
# then you must also specify it here.
;cipher x

# Enable compression on the VPN link.
# Don't enable this unless it is also
# enabled in the server config file.
comp-lzo

# Set log file verbosity.
verb 3

# Silence repeating messages
mute 20
--------------------------------------------------

doppio clic sul file ovpn e si aggiunge questa configurazione a TunnelBlick
per connettersi e' sufficiente andare sull'icona vicino all'orologio ed effettuare la connessione

Condensatore della lavatrice

Per l'angolo del fai da te come riparare il condensatore di una lavatrice




Un paio di giorni fa la lavatrice ha smesso di funzionare, o meglio l'acqua entrava nel cestello, il cestello tentava di girare ma faceva solo un piccolo angolo di rotazione (la centrifuga a vuoto funzionava a velocita' ridotta)

Il colpevole e' stato individuato individuato nel condensatore del motore elettrico (per capire a cosa serve il condensatore detto "di spunto" qui c'e' una chiara spiegazione). Questo e' il pezzo smontato


il costo e' di circa 8 euro e ve ne sono di tre capacita 12-14-16 microFarad. Ha 4 poli ma sono cortocicuitati a due a due (in alcuni modelli non e' possibile vedere come sono uniti insieme i poli perche' la plastica nasconde i contatti, meglio munirsi di tester)



Nel mio caso il condensatore era facilmente accessibile dall'alto. E' avvitato alla scocca mediante un dado che esce dalla scocca sul retro
15-20 minuti di lavoro


venerdì 23 gennaio 2015

VPN Host to Lan con Zeroshell e VirtualBox


In questo post viene mostrato come configurare una VPN Host to Lan mediante l'uso di Zeroshell (il  tutto virtualizzato per comodita' su VirtualBox)

Lo scenario e' il seguente:
1) un server su rete interna con indirizzi 10.0.0.x su cui gira un server SSH. Lo scopo e' di collegarsi via VPN a questo server (per la cronaca e' una installazione minimale di Debian)

2) una macchina router cui gira Zeroshell, una distribuzione firewall/router che ha integrata un server VPN basato su OpenVPN. Questa macchina ha due schede di rete: una WAN con indirizzo 150.217.xx.xx ed una scheda interna che collega la LAN 10.0.0.x

3) una macchina esterna, in particolare una Ubuntu, che deve accedere come client alla VPN




Per la virtualizzazione un paio di indicazioni:
1) Tutte le macchine virtuali devono avere le schede di rete virtuali in modalita' Bridge
2) La macchina Zeroshell deve avere due interfacce di rete in quanto lavora come router. Facendo le prove su un portatile ho montato una scheda di rete USB

Questa e' la configurazione degli indirizzi di rete. L'interfaccia VPN99 e' virtuale ed e' ovviamente quella della VPN



Si aggiunge un utente (username/password) che dovra' accedere alla VPN


si imposta poi la VPN (modalita' Host to Lan, primo tab). Da notare che e' stata reimpostata la porta di ascolto di default di OpenVPN (spostata su 8080/TCP). Il pool di indirizzi della VPN e' del tipo 192.168.250.x ma non interessa molto perche' saranno trasparenti. Da ricordarsi di spuntare NAT

A questo punto e' bene salvarsi il file del certificato del server (sara' poi installato sul client). Si deve entrare su Trusted CAs ed esportare il file TrustedCas.pem


Per avvisare Zeroshell come instradare verso la rete interna il traffico VPN si deve cliccare il pulsante Net nella schermata precedente e settare il pool di indirizzi della rete interna


La parte Zeroshell e' terminata, passiamo a configurare il client. Su Ubuntu e' particolarmente immediato. Dal menu della configurazione delle interfacce di rete si puo' impostare anche un nuovo client VPN. In questo caso si deve selezionare OpenVPN come tipologia di connessione
Si seleziona l'indirizzo WAN di Zeroshell e si inseriscono le credenziali dell'utente ed il certificato del server (TrustedCa.pem)


Si va quindi in configurazione avanzate e si modifica la porta di ascolto (8080) e si spunta la compressione LZO e TAP (questo e' importante, altrimenti la connessione va in TUN e ci si collega alla VPN ma non si arriva sulla rete interna)



a connessione avvenuta deve comparire l'interfaccia virtuale


a questo punto si si puo' collegare da qualunque rete alla rete interna sul server ssh (sempre che la rete da cui ci si connette non filtra la porta 8080 ma cio' e' improbabile perche' sulla stessa porta girano spesso servizi web)






venerdì 16 gennaio 2015

Stampante WiFi con Arduino YUN (USB over IP)


In questo post viene mostrato come convertire una economica stampante in una stampante WiFi mediante l'utilizzo di Arduino YUN.

Di fatto YUN ha un hardware troppo ridotto per portersi permettere l'installazione di un server CUPS ma si puo' utilizzare un software USB over IP per ottenere un risultato simile. In pratica il programma instrada tutto il traffico del protocollo USB incapsulandolo sulla rete WiFi ed un client sul portatile permette di recodificarlo eliminando di fatto il supporto fisico del cavo USB



Samsugn ML2160 modificata in modalita' WiFi


Per i puristi di Linux e dell'OpenSource esiste un progetto USB/IP che permette di fare quanto descritto ma si tratta di un progetto non mantenuto (gli ultimi aggiornamenti sono del 2011) e non ha client per Mac e Windows
Io ho usato invece VirtualHere che permette l'uso gratuito del programma collegando un solo dispositivo ed ha server compilati in modo statico per praticamente tutti i sistemi operativo (anche quelli embedded come Arduino) e client per Linux, Windows e Mac


Visto YUN ha un processore MIPS si deve scaricare e lanciare il programma server vhusbdmips
Sul client si deve scaricare il programma apposito e si clicca destro sul dispositivo (in questo caso la stampante) per collegare la porta usb virtuale (i driver della stampante devono essere installati sul client)

da qui in poi il portatile vedra' la stampante come fisicamente connessa alla porta USB

Lo stesso si puo' fare con qualsiasi dispositivo come una webcam usb (testato con VLC, unico problema non sono riuscito ad ottenere la massima risoluzione)



e si possono collegare anche dischi remoti (un po' come fosse Time Capsule del marchio della mela morsicata)


ATTENZIONE : in questo caso funzionano bene le chiavette USB ma non i dischi esterni. YUN non riesce ad alimentare correttamente i dischi esterni per limiti sulla tensione in uscita. Se il disco esterno non ha l'alimentazione separata dall'USB molto probabilmente non funzionera'










mercoledì 14 gennaio 2015

Tasto insert su Mac

Ultimamente uso spesso Mac come portatile anche se di fatto sono quasi sempre collegato in shell con qualche macchina Linux


Una delle cose piu' seccanti su Mac e' la mancanza del tasto INS ed usando Midnight Commander la cosa diventa pesante.
Frugando su Internet ho trovato che questo tasto su Os X e' sostituito dalla combinazione CTRL+T
(per quanto riguarda i tasti funzione F1..F10 si ottengono premendo la combinazione Fn+F1, per l'impostazione di default devono essere modificati i tasti F9 ed F10 che sono destinati ad Expose')

ACME Terra

A seguito del precedente post, maggiori dettagli sulle impressioni di uso sulla scheda Terra

Per punti

1) la scheda non e' alimentabile da USB (almeno io non ci sono riuscito)

2) La comunicazione avviene mediante il modulo DPI (tipo FTDI di Arduino) che crea una porta seriale virtuale con cui si puo' aprire un Terminale Seriale ed entrare in shell

3) La scheda viene venduta con una microSD con sopra montata una versione di EMDebian (Emdebbed Debian). Al momento attuale, o meglio dal lulgio 2014, questa distribuzione e' morta e sono spariti anche i repository. EMDebian consigliano di usare una Debian pura e ACME riporta le istruzioni per crearsi  l'immagine Debian per la SDCard (al link sono disponibili le immagini Debian aggiornate al Novembre 2014)

4) La password di root della distribuzione giunta con la scheda SD e' "ariag25". Nel sito in alcune pagine risulta la password si "acmesystems" (sono un po' impazzito prima di trovare il link giusto)

4) Curiosamente dopo aver settato via terminale seriale l'ip ad eth0, ho attaccato il cavo cross per entrare in SSH ma le luci della scheda non si accendono. Se

5) il convertitore analogico digitale e' a 10 bit come su Arduino (o meglio come sulle Arduino base)

6) la scheda Terra, al confronto della Fox, necessita' di ulteriore hardware per accedere alle porte analogiche. Con un costo aggiuntivo di  una ventina di euro si acquista  l'adattatore Daisy Chain; nella Fox invece i contatti sono esposti anche se vanno saldati (non ci sono gli header come in Arduino in nessuna delle due schede)

7) Un kit Terra completo costa circa 200 euro a cui sono da aggiungere le spese per le espansioni. Sicuramente l'elettronica e' di piu' alta qualita' rispetto ad Arduino ma non e' esattamente una soluzione economica per fare prototipizzazione

NTP Server con GPS via Android


In questo post viene spiegato come poter utilizzare un telefono Androided  un calcolatore con Linux per creare un semplice NTP server
Questa funzione e' utile nel caso che si abbiano diversi sensori che necessariamente devono lavorare ben sincronizzati ed e' stata necessaria dopo la recente vulnerabilita' di   NTP quando l'amministratore di una grande rete a cui mi appoggio ha deciso di tagliare tutto il traffico NTP (senza peraltro avvisare gli utenti)

Era richiesto che il PC ed il telefono fossero collegati via cavo USB (e non via Bluetooth) in modo da non avere perdita di connessione ed in modo anche di alimentare in modo semplice il telefono


Sul telefono Android si deve installare ed avviare l'applicazione BlueNMEA e si collega il telefono al PC (la modalita' sviluppatore deve essere attivata per aprire il canale ADB)




a questo punto da shell si forwarda tutto il traffico sul protocollo ADB verso la porta 4352 TCP del calcolatore

adb forward tcp:4352 tcp:4352

per verificare la connessione si puo' usare telnet

telnet localhost 4352

se tutto e' andato a buon fine si dovrebbero passare i messaggi NMEA (anche se non si e' ottenuto il fix del GPS si vedono comunque le stringhe)

a questo punto si puo' installare il demone GPSD 

apt-get install gpsd gpsd-clients python-gps

si lancia quindi il demone che ascolta la porta 4352 dopo prima era stato dirottato il trafffico GPS del telefono

gpsd tcp://localhost:4352

per verificare se funziona il demone si puo' usare a linea di comando 

cgps -d

mentre in X

xgps


per fare in modo da usare il dato del tempo per il server del tempo si deve installare il demone di NTP

apt-get install ntp 

e si modifica il file di configurazione in /etc/ntp.conf


# gps ntp
server 127.127.28.0 minpoll 4
fudge 127.127.28.0 time1 0.183 refid NMEA
server 127.127.28.1 minpoll 4 prefer
fudge 127.127.28.1 refid PPS

si riavvia il servizio e si puo' interrogare


ntpq -p

lunedì 12 gennaio 2015

Arduino YUN e Webcam con Fswebcam

Questo post in realta' non e' esclusivo di Yun perche' riguarda solo la parte Linux della Yun ed e' quindi applicabile anche a PC, Raspberry o sistemi simili...in ogni caso mostra come trasformare una webcam in una Ip camera con Arduino YUN


Per l'esempio ho usato una comune (e vecchiottta) webcam Logitech C310 che e' stata collegata alla porta USB della YUN. Il sistema ha riconosciuto il device senza problemi

a questo punto si devono aggiungere i moduli per FSwebcam, un programma che permette di prendere fotografie in automatico dalla webcam

si procede quindi con

opkg update
opkg install kmod-video-uvc
opkg install fswebcam

in Linino le librerie GD sono compilate senza il supporto ai font TrueType quindi non si possono aggiungere banner sopra l'immagine

Il sistema migliore e' di crearsi un file di configurazione che poi' sara lanciato come segue

fswebcam -c fswebcam.conf

questo il mio file di configurazione
In pratica vengono eliminati i primi 5 frame (la webcam non entra in funzione subito). viene effettuato uno scatto ogni 4 secondi con una risoluzione di 1280x720 alla qualita' 95% di jpg

i dati vengono salvati sulla schedina SD (come copia di backup) e viene salvata una immagine, sempre con lo stesso nome, sulla cartella del webserver dove ho messo una semplice pagina html che si aggiorna ogni n secondi

----------------------------------------------------
device /dev/video0
input 0
loop 4
skip 5
#background
resolution 1280x720
jpeg 95
#top-banner
#timestamp "%d-%m-%Y %H:%M:%S"
save "/www/camera/immagine.jpg"
save "/mnt/sda1/%Y%m%d-%H%M%S.jpg"

Potenza di calcolo Arduino Yun vs ACME Terra vs MacBook

Un amico usa normalmente per acquisizione delle schede Terra ACME ed sostanzialmente mi ha lanciato una sfida se fosse piu' performante nel calcolo puro la sua Terra o la mia YUN




Il terreno di battaglia e' stato scelto con l'elaborazione dello script in Python per la creazione di un insieme di Mandelbrot



Lo script nel dettaglio e' il seguente
--------------------------------------------------
from PIL import Image
from PIL import ImageDraw
# drawing area
xa = -2.0
xb = 1.0
ya = -1.5
yb = 1.5
maxIt = 255 # max iterations allowed
# image size
imgx = 512
imgy = 512
image = Image.new("RGB", (imgx, imgy))

for y in range(imgy):
    zy = y * (yb - ya) / (imgy - 1)  + ya
    for x in range(imgx):
        zx = x * (xb - xa) / (imgx - 1)  + xa
        z = zx + zy * 1j
        c = z
        for i in range(maxIt):
            if abs(z) > 2.0: break 
            z = z * z + c
        image.putpixel((x, y), (i % 4 * 64, i % 8 * 32, i % 16 * 16))

image.save("mandel.bmp", "BMP")
--------------------------------------------------

Su Arduino Yun e' stato necessario installare il pacchetto python-imaging-library.
Su Terra si e' presentato un problema inatteso. I repository di EmDebian (Embedded Debian) non sono piu' disponibili per cui il programma e' stato fatto girare eliminando i riferimenti alle librerie grafiche (dando quindi un piccolo vantaggio a Terra)

Alla fine il risultato e' stato meno definitivo di quanto creduto
Terra ha impiegato 11 minuti e 35 secondi contro i 14 minuti e 52 secondi di Yun (per confronto un MacBook i5 impiega 6.1 secondi)....considerando che Arduino Yun costa circa 62 Euro in confronto ai 199 euro di Terra Kit  la mia scelta e' piu' orientata verso la Yun (con circa 200 euro si iniziano a comprare dei portatili completi come i ChromeBook)

SismoArduino (142Hz)

Riprendendo il progetto di SismoArduino ho voluto anche qui provare a migliorare le prestazioni del passo di campionamenti


Le modifiche hanno riguardato sostanzialmente la riduzione dei tempi di ritardo tra le letture e l'uso di un pc piu' perfomante rispetto a quello usato in precedenza
Con queste modifiche il passo di campionamento e' salito ad 1 campione ogni 7 millisecondi in linea con quanto provato con SismoYUN (a questo punto questo puo' essere il limite della scheda senza entrare in modalita' free running)

----------------------------------------------------
#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] = {192,168,1,1};
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);    
}
----------------------------------------------------

venerdì 9 gennaio 2015

Recuperare il controllo di Arduino YUN con YunSerialTerminal

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


Arduino UDP Broadcast (SismoArduino)

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
-------------------------------------------
import socket,select

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,1)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST,1)

sock.bind(('',5005))


while True:
    msg,add = sock.recvfrom(1024)
    print msg

-------------------------------------------

giovedì 8 gennaio 2015

SismoYUN (142Hz)

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





YUN e Memoria USB

Piu' studio Arduino Yun piu' mi diverto. E' possibile anche attaccardi pennette USB per aumentare lo spazio disco oltre a quello fornito dalla SDCard



per farlo si deve pero' installare il pacchetto kmod-usb2

opkg update
opkg install kmod-usb2 
insmod ehci-hcd

se presente /dev/sda1 e' occupato dalla SDCard
per montare la chiavetta usb si monta /dev/sdb1

mount /dev/sdb1 /mnt/usbkey

mercoledì 7 gennaio 2015

SismoYUN (30 Hz)

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

venerdì 2 gennaio 2015

SismoYUN

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);
?>
--------------------------------------------------------------

e questa e' la pagina di presentazione
--------------------------------------------------------------
<html>
<META HTTP-EQUIV="refresh" CONTENT="900">
<head>
<script type="text/javascript"
  src="dygraph-combined.js"></script>
</head>
<body>
<div id="graphdiv2"
  style="width:1000px; height:700px;"></div>
  <br>

<script type="text/javascript">
  g2 = new Dygraph(
    document.getElementById("graphdiv2"),
    "dati.php", 
    {title: 'SismoYUN'}          // options
  );

 var update = function(){
 g2.updateOptions({'file': 'dati.php'});  
 };
  window.setInterval(update,1000);  
</script>
</body>
</html>
--------------------------------------------------------------



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

Bridge su Arduino Yun

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)

------------------------------------------------------------
#include <Bridge.h>

void setup() {
  Bridge.begin();
}

void loop() {
  Bridge.put("A3",String(analogRead(A3)));
  delay(2);
   
}
------------------------------------------------------------

Sulla parte Linux il valore puo' essere letto mediante uno scritp in Python come di seguito mediante una get
------------------------------------------------------------
#!/usr/bin/python
import time
import sys

sys.path.insert(0,'/usr/lib/python2.7/bridge/')

from bridgeclient import BridgeClient as bridgeclient

value = bridgeclient()

while True:
    x1 = value.get("A3");
    print x1
    time.sleep(2);
------------------------------------------------------------
tutto molto lineare tranne il fatto e' che disperatamente lento (diciamo un ciclo al secondo)

Installare LAMP su Arduino Yun

Tecnicamente parlando non e' proprio un LAMP (Linux+Apache+Mysql+PHP) ma piuttosto un LUMP (Linux+Uhttpd+Mysql+PHP) ma il concetto e' il medesimo




In aggiunta ho installato anche il sempre utile Midnight Commander per avere un editor un po' piu' umano di Vi

La configurazione parte collegandosi in SSH alla shell della Yun

ssh root@arduino.local

e lanciano prima un aggiornamento dei pacchetti

okpg update

per Midnight Commander ed unzip (che servono sempre)

opkg install mc 
opkg install unzip

per quanto riguarda Uhttpd, questo risulta configurato di default per cui non e' necessario fare niente di speciale. La directory dove devono essere posti i file e' in /www (direttamente nella root). Gli scrpt di amministrazione sono /etc/init.d/uhttpd

Per aggiungere PHP5 si lancia

opkg install php5 php5-cgi

al termine si deve modificare il file di configurazione di Uhttpd (/etc/config/uhttpd) e decommentare la riga dell'interprete php-cgi.
Riavviando il servizio uhttod e creando una file info.php (phpinfo) nella root si ottiene la risposta che l'interprete funziona


Tocca adesso a Mysql. Per avere un po' piu' di spazio ho spostato il database sulla scheda SD (che e' montata in /mnt/sda1)

opkg install libpthread libncurses libreadline mysql-server
sed -i 's,^datadir.*,datadir = /mnt/sda1/mysql,g' /etc/my.cnf
sed -i 's,^tmpdir.*,tmpdir = /tmp/,g' /etc/my.cnf
mkdir -p /mnt/sda1/mysql
mysql_install_db –-force
/etc/init.d/mysqld start
/etc/init.d/mysqld enable
mysqladmin -u root password 'password_root_mysql'


adesso e' il momento dei connettori
PHP5-Mysql

opkg install php5-mod-mysql
sed -i 's,;extension=mysql.so,extension=mysql.so,g' /etc/php.ini


Python-Mysql (Python 2.7 e' incluso di default per cui non risulta necessario installarlo)

opkg install python-mysql

e per terminare qualcosa che non deve mai mandare ovvero il server SFTP (che non e' montato di defualt)

opkg install openssh-sftp-server

Per iniziare a lavorarci sopra e' meglio inserire i  file per il webserver sulla scheda SD, sia per problemi di spazio che per il numero di cicli di lettura/scrittura limitati della memoria della Yun. Senza modificare le impostazioni del webserver la cosa piu' semplice e' creare un link simbolico (in questo modo funzionano pero' solo i file html, per i file in php deve essere riconfigurato il server)