L’articolo precedente illustrava come creare un account no-ip.com con relativo host che tenesse traccia dell’ip del router “domestico”. Questa procedura richiede l’installazione di un update client sul pc, nella rete domestica, capace di aggiornare periodicamente l’host remoto.

L’operazione risulta scomoda poiché il PC deve rimanere acceso per effettuare l’aggiornamento. Fortunatamente esiste un metodo basato su richiesta http che permette di utilizzare direttamente Arduino per sincronizzare l’host con l’ip del router.

La richiesta di aggiornamento va indirizzata a uno di questi URL

http://dynupdate.no-ip.com/nic/update

https://dynupdate.no-ip.com/nic/update

mentre la struttura della richiesta deve seguire questo formato

GET /nic/update?hostname=Nomehost&myip=IndirizzoIP HTTP/1.0
Host: dynupdate.no-ip.com
Authorization: Basic NomeUtentePasswordBase64
User-Agent: NomeClient/Versione IndirizzoMail

dove

NomeHost = Il nome dell’host come registrato nella procedura Create Host del sito no-ip.com
IndirizzoIP = Qui va messo l’indirizzo ip che vogliamo associare all’host remoto
NomeUtentePasswordBase64 = Qui dobbiamo inserire il nome utente e la password del nostro account no-ip in formato Base64. Il nome utente e la password vanno separati da un segno di due punti (Nomeutente:Password)
NomeClient = Il nome del client che esegue l’aggiornamento (Nome di libera scelta)
Versione = La versione del client che esegue l’aggiornamento (Nome di libera scelta)
IndirizzoMail = il nostro indirizzo mail (Mail di libera scelta)

quindi la richiesta assumerà questa struttura

GET /nic/update?hostname=host.no-ip.com&myip=192.168.1.1 HTTP/1.0
Host: dynupdate.no-ip.com
Authorization: Basic aW86YW1vIGlsIHRhZWt3b25kbw==
User-Agent: arduino_ethernet/1.0 info@gmail.com

Il problema principale è che Arduino non si riesce a ottenere, direttamente e in modo semplice,  l’ip dinamico del router per poterlo inserire nella richiesta http. Fortunatamente omettendo totalmente questo parametro, il servizio  dynupdate.no-ip.com utilizza l’ip della connessione che corrisponde proprio all’indirizzo dinamico del nostro router. La richiesta, per funzionare, va riscritta in questo modo:

GET /nic/update?hostname=host.no-ip.com HTTP/1.0
Host: dynupdate.no-ip.com
Authorization: Basic aW86YW1vIGlsIHRhZWt3b25kbw==
User-Agent: arduino_ethernet/1.0 info@gmail.com

Utilizziamo per questo test direttamnete lo scketch di esempio proposto dall’IDE (File->Examples->Ethernet->WebClient) e modifichiamolo secondo le nostre esigenze.

Per creare la connessione, nello skecth non è possibile immettere direttamente l’url del servizio (dynupdate.no-ip.com) ma il suo relativo indirizzo ip ottenibile tramite il sito mostraip.it.

Modifichiamo il codice:

#include <Dhcp.h>
#include <Dns.h>
#include <Ethernet.h>
#include <EthernetClient.h>
#include <EthernetServer.h>
#include <EthernetUdp.h>
#include <SPI.h>


byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //mac ethernet
byte ip[] = { 192, 168, 1, 190 }; //indirizzo locale dell’Arduino
byte server[] = {8, 23, 224, 120}; //dynupdate.no-ip.com

//creo un client che punta al
//servizio dynupdate.no-ip.com sulla porta 80
EthernetClient client;

void setup() {
  //Avvio la connessione
  Ethernet.begin(mac, ip);
  //inizializzo la seriale
  Serial.begin(9600);
  //aspetto che il chip wiznet sia inizializzato
  delay(1000);

  Serial.println("Connessione in corso…");

  //se la connessione avviene con successo
  //invio la richiesta http
  if (client.connect(server, 80)) {
    Serial.println("Connesso");

    client.println("GET / nic / update ? hostname = host.no - ip.com HTTP / 1.0");
    client.println("Host: dynupdate.no - ip.com");
    client.println("Authorization: Basic aW86YW1vIGlsIHRhZWt3b25kbw == ");
    client.println("User - Agent: arduino_ethernet / 1.0 info@gmail.com");

    client.println();
  }
  else
  {
    //Problemi nella connessione
    Serial.println("connessione fallita!");
  }
}

void loop()
{
  //restituisco il messaggio inviato dal servizio
  if (client.available()) {
    char c = client.read();
    Serial.print(c);
  }

  //Quando il server si disconnette fermo il client
  if (!client.connected()) {
    Serial.println();
    Serial.println("Disconessione");
    client.stop();

    //ciclo infinito
    for (;;)
      ;
  }
}

Questo procedimento, secondo me, risolve il fastidioso problema di tenere il pc accesso per eseguire la sincronizzazione tra l’ip del router e l’host remoto, permettendo quindi di creare soluzioni web-based impiegando Arduino.

In allegato trovate un semplice programma che vi permette di convertire il vostro nome utente e la password in una stringaBase64, per far girare il programma dovete avere installato il .net framework 2.0

ConvertBase64

The post Come aggiornare l’ host no-ip tramite Arduino ethernet appeared first on Esperimenti con logiche programmabili.

Una funzionalità sempre utile è la possibilità di accedere alle risorse della board Arduino tramite un collegamento internet. Questa operazione non è particolarmente difficile anche se i passaggi da eseguire sono diversi, questo tutorial permette di controllare Arduino da remoto.
La prima cosa da risolvere è rintracciare l’indirizzo ip del nostro router per accedere alla rete locale dove è collegato l’Arduino. Solitamente l’ip dei router è dinamico, quindi può cambiare inavvertitamente rendendo impossibile conoscerlo da una postazione remota. Fortunatamente esistono dei servizi che risolvono questa necessità, permettendo, tramite un piccolo software che gira sul pc (o in alcuni casi direttamente sul router locale) di aggiornare un servizio web che memorizza l’indirizzo del router locale.

Il servizio che ho scelto per questo articolo è offerto dal sito no-ip.com. Prima di utilizzare le sue funzioni dobbiamo creare un account (free) compilando il relativo form

Una volta ottenuto, eseguiamo il login per accedere alla pagina dei servizi. Clicchiamo sul link Hosts/Redirects e poi sul link Add Host

compiliamo i relativi campi che permettono di associare un host al nostro indirizzo ip corrente.
Nel campo Hostname inseriamo un nome che identificherà il nostro host, la combo box elenca i nomi di dominio disponibili, selezioniamone uno a piacere tra quelli free.
Selezioniamo tramite le checkbox l’Host Type, per la nostra applicazione  va bene quello di default (DNS Host(A)).
Nella casella Ip Address sarà presente l’indirizzo attuale del nostro router.
Concludiamo la creazione dell’host cliccando sul pulsante Create Host.

Ora scarichiamo l’utility che aggiornerà l’host con l’indirizzo ip del router locale. Clicchiamo sul link Download Client:

selezioniamo il sistema operativo in uso sul computer, eseguiamo il download e successivamente la semplice installazione.

Una volta installato il client sul pc, eseguiamolo per configurare le prime impostazioni. Inseriamo innanzitutto l’indirizzo mail e la password relativi all’account no-ip.com precedentemente creato

Una volta effettuato l’accesso, il client ci invita a selezionare l’host da aggiornare, spuntiamo la checkbox relativa all’host creato precedentemente

salviamo per rendere operativo l’aggiornamento dell’ip.
Nella sezione preferenze del client spuntiamo la voce per eseguire automaticamente il programma all’accesso del sistema operativo.

Ritornando nella pagina Menage Host sul sito no-ip potremmo conoscere costantemente l’indirizzo del router locale da qualsiasi posizione della rete Internet.

Configurare Arduino Ethernet per rispondere alle richieste web

Per semplicità utilizzerò lo scketch di esempio Webserver (dall’IDE arduino File->Examples->Ethernet->WebServer), modifichiamo l’indirizzo ip dell’Arduino con un indirizzo compatibile con la nostra rete locale. Nel mio caso ho lasciato quello di default 192.168.1.177.

Verifichiamo tramite un pc della rete locale che l’Arduino risponda alle richieste http, apriamo il browser e nella barra degli indirizzi scriviamo l’ip della board Arduino (192.168.1.177) e premiamo invio. In assenza di problemi dovremmo ottenere qualcosa del genere

Configurare il router per le richieste remote

Questa è la parte più delicata perchè cambia da router a router ma teoricamente è necessario utilizzare la sezione virtual server del router, inserire nell’apposito campo l’indirizzo ip della board Arduino e sbloccare la porta 80 per il relativo indirizzo. In questo modo le richieste http remote verranno processate dalla board Arduino.

Collaudare il sistema

Ora tutto è pronto per il test finale. Da una postazione remota collegata ad internet apriamo il browser e digitiamo il nome dell’host come definito nella pagina Menage Host del sito no-ip.com, se tutto è stato impostato correttamente otterremo la risposta dell’Arduino cosi come nella prova locale.

In questo modo potremmo accedere alle risorse dell’Arduino per leggere dati o per pilotare i suoi pin digitali. Vi invito a leggere gli articoli precedenti per approfondire l’argomento.

The post Come controllare Arduino direttamente da internet appeared first on Esperimenti con logiche programmabili.

La nuova board Arduino Ethernet ha in dotazione uno slot per scheda micro SD (Secure Digital) utile per dare la possibilità ai nostri programmi di memorizzare varie informazioni. La libreria permette di lavorare su schede formattate con file system FAT16 e FAT32, i nomi dei file devono essere composti da massimo 8 caratteri più 3 per l’estensione (formato 8.3 stile MS-DOS).

Come molte libreria dobbiamo inserire un riferimento nello sketch che la utilizza:

//inserisco riferimento alla libreria SD
#include <SD.h>

successivamente, nel blocco setup, bisogna inizializzare la classe utilizzando il metodo begin(). A questo metodo dobbiamo passare il pin relativo alla funzione Card Select (CS) che per la Arduino Ethernet è uguale a 4, come visibile nello schema elettrico

//inizializza la classe e specifica
//il pin Card Select
SD.begin(4);

Il metodo restituisce false se si verificano problemi durante l’inizializzazione. Quindi prima di continuare è fondamentale verificare chequesta si concluda senza errori

if (SD.begin(4) == true)
//inizializzazione ok
//continua con il codice
else
//problemi nell'inizializzazione!

Per poter scrivere e leggere file dalla micro SD abbiamo bisogno di utilizzare la classe File che espone metodi che svolgono questo compito.
Creiamo un oggetto dalla classe File subito dopo la dichiarazione della libreria SD:

//inserisco riferimento alla libreria SD
#include <SD.h>

//creo un oggetto dalla classe File
File MioFile;

Utilizziamo il metodo open() della classe SD per aprire un file esistente; il metodo restituisce un riferimento che viene associato all’oggetto MioFile:

//dopo l'inizializzazione posso lavorare sulla micro SD
//Apro un file di testo
MioFile = SD.open("filetest.txt", FILE_WRITE);

Da notare che se il file non esiste nella micro SD il metodo open() ne crea uno automaticamente.

il metodo open() della classe file accetta come argomenti due parametri, il primo è il nome del file, il secondo è un flag che indica se aprire il file in lettura o in scrittura, le opzioni sono:

Se non si verificano errori il metodo open() restituisce il riferimento al file, in caso di errore invece restituisce false; è buona norma controllare tramite un blocco if se si sono verificati errori:

//dopo l'inizializzazione posso lavorare sulla micro SD
//Creao un file di testo
MioFile = SD.open("filetest.txt", FILE_WRITE);

if (MioFile == false)
//problemi nell'accesso al file

Utilizziamo il metodo println() dell’oggetto MioFile per scrivere dati sul file appena aperto

//se non ci sono problemi nell'apertura dei file scrivi
//qualcosa al suo interno
if (MioFile != false)
MioFile.println("Ciao Mondo");

Una volta ultimate le fasi di scrittura, se non intendiamo scrivere altro è consigliabile rilasciare le risorse chiudendo il file con il metodo close()

//chiudo il file
MioFile.close()

La fase di lettura è analoga a quella di scrittura, si procede aprendo il file con il metodo open() ed eseguendo il metodo read() dell’oggetto MioFile

//Apro il file per la lettuta
MioFile = SD.open("filetest.txt", FILE_READ);

//Se non si sono verificati errori
//leggo il file
if (MioFile == true)
{

//Leggi fino alla fine del file
while (MioFile.available())
{
//read esegue la lettura di un byte alla volta
Serial.write(MioFile.read());
}

// close the file:
MioFile.close();
}

Il metodo available() restituisce il numero di byte disponibili  tra il puntatore e la fine del file. Il puntatore rappresenta un indice, o per rendere meglio l’idea, un cursore all’interno del file aperto.
Quando apriamo il file il puntatore viene posizionato sul primo byte quindi il metodo available() restituisce il numero di byte compresi tra il puntatore e la fine del file stesso. La read() legge il primo byte (dato che il puntatore si trova all’inizio del file) e fa avanzare il cursore di una posizione.
L’illustrazione seguente spiega meglio il concetto, (viene preso in considerazione un file di 100 byte)

Quando il file viene aperto il cursore punta sul primo byte e available() restituisce 100

Dopo la read() il cursore avanza di un byte spostandosi al secondo byte del file. Il metodo available() restituisce 99

Ogni volta che eseguiamo la read() il puntatore scorre fino ad arrivare alla fine del file (EOF) in questa posizione available() restituisce 0.

Il ciclo while() esegue la read() ciclicamente fino a quando il valore di available() restituisce zero.

Una volta eseguita la lettura, se non intendiamo fare altro con il file, è consigliabile eseguire il metodo close() per rilasciare risorse e chiudere il file correttamente.

//chiudo il file
MioFile.close()

Verificare l’esistenza di un file o di una directory

La classe SD espone alcuni metodi utili per gestire la nostra micro SD, uno di questi permette di verificare l’esistenza di un file all’interno di un percorso, il metodo è exists() e viene utilizzato in questo modo

//verifico l'esistenza di un file
if (SD.exists("filetest.txt"))
//true -> il file esiste
else
//false-> il file non esiste

possiamo includere anche un percorso di cartelle

//verifico l'esistenza di un file in un percorso
if (SD.exists("arduino/arduino0022/filetest.txt"))
//true -> il file esiste
else
//false-> il file non esiste

con lo stesso metodo verifichiamo l’esistenza di una directory

//verifico l'esistenza di un file in un percorso
if (SD.exists("arduino/arduino0022"))
//true -> la directory arduino0022 esiste
else
//false-> la directory arduino0022 NON esiste

Come cancellare un file dalla micro SD

Dopo aver eseguito diverse prove creando diversi file sulla micro SD possiamo liberare un po di spazio cancellandone qualcuno. Il metodo remove() della classe SD esegue questo compito, il suo utilizzo è molto semplice e l’unico parametro da passargli è il nome del file da cancellare:

//Cancella il file di test
SD.remove("filetest.txt");

Se la cancellazione avviene con successo la funzione restituisce true altrimenti false.

//Cancella il file di test
if (SD.remove("filetest.txt"))
Serial.println("File eliminato!");
else
Serial.println("Problemi nell'eliminazione");

Creare ed eliminare directory

Anche per la creazione ed eliminazione di directory è sufficiente utilizzare i metodi della classe SD, per la creazione utilizziamo il metodo mkdir mentre per l’eliminazione utilizziamo il metodo rmdir

//Creo una directory
if(SD.mkdir("arduino"))
Serial.println("Directory creata");
else
Serial.println("Problemi nella creazione della directory");

con mkdir è possibile creare anche le sottodirectory in un colpo solo

//Creo directory e sottodirectory
if(SD.mkdir("arduino/arduino1/arduino2"))
Serial.println("Directory create");
else
Serial.println("Problemi nella creazione della directory");

il codice precedente crea tre cartelle nidificate (arduino, arduino1 e arduino2) utilizzando solamente una singola istruzione.
Per eliminare le directory utilizziamo il metodo rmdir() in questo modo

//Elimina la directory
if(SD.rmdir("arduino"))
Serial.println("Directory Eliminata");
else
Serial.println("Problemi nell'eliminazione della directory");

rmdir() non può eliminare una directory se all’interno sono presenti altre sottodirectory oppure file, bisogna quindi svuotale e poi eliminarle singolarmente

//Elimina le directory vuote
SD.rmdir("arduino2");
SD.rmdir("arduino1");
SD.rmdir("arduino");

La gestione della micro SD risulta essere molto semplice e comoda per le diverse applicazioni che hanno bisogno di memorizzare dati piuttosto che recuperarne per eseguire calcoli o comparazioni. Nel prossimo articolo vedremo come utilizzare queste funzioni per creare un data logger.

The post Arduino ethernet utilizzare la scheda micro SD appeared first on Esperimenti con logiche programmabili.

Ho da poco ricevuto il pacco contenente la board Arduino Ethernet, e devo dire che risulta essere ben realizzata ed assemblata. Prima di iniziare a scrivere qualche sketch è necessario installare i driver del convertitore USB2Serial che utilizzeremo per colloquiare con la board dato che non dispone di una porta usb integrata come la Arduino UNO, inoltre modificheremo il file board.txt per aggiornare il menu dell’IDE.

Scarichiamo dal sito Arduino.cc i driver del convertitore usb seriale che potete trovare nella sezione Driver & Setup nella pagina del dispositivo USB2Serial Light, salviamo e decomprimiamo il file in una cartella sul desktop.
Quindi colleghiamo al pc, tramite cavo mini usb, la board Usb2Serial.

Windows XP avvierà la procedura di installazione nuovo hardware

Clicchiamo sul pulsante Annulla per chiudere la finestra. Un messaggio pop-up ci avviserà del relativo errore, non badateci e chiudete il messaggio:

Ora apriamo la finestra delle proprietà del sistema, Start->Pannello di controllo->Sistema e clicchiamo sul tab Hardware

apriamo la finestra gestione periferiche tramite l’omonimo pulsante, dovremmo notare la presenza del device Arduino USB-Serial.

Clicchiamo con il pulsante destro del mouse sul dispositivo e selezioniamo la voce Aggiorna driver… per avviare la procedura passo passo che porterà alla corretta installazione dei driver della board USB2Serial; di seguito le schermate illustrative del wizard di installazione:

Se non ci sono intoppi la procedura permetterà immediatamente l’utilizzo della board USB2Serial. Il passo successivo permette di aggiornare l’elenco delle board presenti nel relativo menu dell’IDE.
Dobbiamo aprire il file board.txt situato nel seguente path:

arduino-0022\hardware\arduino

cerchiamo la seguente stringa

uno.name=Arduino Uno

e modifichiamola in questo modo

uno.name=Arduino Uno or Ethernet

Dato che programmare la Arduino Ethernet equivale a programmare l’Arduino UNO, questa modifica serve solamente a rinominare la voce del menu, non ha effetto sui parametri della scheda.

Avviamo l’IDE e controlliamo che l’impostazione sia stata caricata

Per concludere carichiamo un semplice sketch per verificare che tutto funzioni in modo adeguato

/*
Test Arduino Ethernet
*/

void setup()
{
//Inizializzo la seriale
Serial.begin(9600);
}

void loop()
{
//scrivo sulla seriale
Serial.write("Arduino Ethernet\n");
//Attendo 1 secondo
delay(1000);
}

Una volta caricato lo sketch apriamo Serial Monitor per verificare che la stringa venga inviata al pc tramite la board USB2Serial.

Prossimi test ed esperimenti nei prossimi giorni

The post Arduino Ethernet come configurare l’ambiente di sviluppo appeared first on Esperimenti con logiche programmabili.

La scheda made in Italy che raccoglie le funzionalità di Arduino più quelle della ethernet shield per fondersi in un unico prodotto. Penso che questa scelta sia fantastica sia per il costo contenuto (rispetto ad Arduino + ethernet shield) sia per le minori dimensioni del prodotto.
Inoltre è presente anche la versione con il modulo PoE (Power over ethernet) che permette di utilizzarla anche in posizioni dove non è presente una fonte di alimentazione esterna.

Vista la mancanza della porta usb, per poterla programmare bisogna acquistare il modulo USB serial adapter.

Tutti i dettagli sul sito Arduino.cc :

Arduino ethernet

USBSerial Adapter

Potete trovare la Arduino ethernet e l’USB adapter da ethermania seguendo questi link

Arduino Ethernet

USB Adapter

The post Scheda Arduino Ethernet all in one appeared first on Esperimenti con logiche programmabili.