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.

Il mondo è sempre più connesso, non solo le persone sono presenti su internet ma anche gli oggetti, tramite semplici circuiti, possono collegarsi alla rete, condividendo dati ed interagendo con l’ambiente, acquisendo grandezze fisiche (tramite sensori) o pilotando carichi utilizzando degli attuatori.

Controllare da remoto uno di questi dispositivi è una operazione affascinante sia per l’utilità di questa tecnica sia, perché no, far stupire i nostri amici accendendo una luce di casa tramite web!

Per chi è alle prime esperienze con Arduino, potrebbe pensare che la realizzazione di questo circuito possa essere complicato e costoso.

Fortunatamente il materiale necessario si riduce a una board Arduino UNO e all’Ethernet shield, più qualche componente esterno.

In questo articolo preferisco fare un piccolo accenno nel descrivere il funzionamento del sistema all’interno della rete lan.

Per il controllo remoto, bisogna eseguire alcune configurazioni aggiuntive che vedremmo successivamente.
Lo schema illustra il funzionamento del progetto:

I pc della rete e l’Arduino UNO (con ethernet shield) sono collegati tra loro tramite uno switch.

Il pc eseguirà, usando un browser, delle richieste http, per recuperare, ad esempio, il valore di una tensione applicata su un pin analogico, oppure accendere o spegnere un led, applicato su un pin digitale in uscita.

Colleghiamo la shield ethernet al nostro Arduino UNO, inseriamo un cavo lan dritto, (che dal connettore rg45 dello shield si collega ad una porta qualsiasi dello switch), inseriamo il cavo USB (che dall’Arduino UNO si collega alla porta del pc) e diamo alimentazione a tutto il sistema.

Apriamo l’IDE di Arduino e scriviamo questo codice:

//Librerie impiegate per il progetto
#include <SPI.h>
#include <Ethernet.h>

//Creao un array di byte per specificare il mac address
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//creo un array di byte per specificare l'indirizzo ip
byte ip[] = {10, 192, 1, 251};

//creo una variabile char per memorizzare i byte letti dal client
char Data_RX;

//creao un oggetto server che rimane in ascolto sulla porta
//specificata
Server ArduinoServer(80);

void setup()
{
  //inizializza lo shield con il mac e l'ip
  Ethernet.begin(mac, ip);
  //inizializza l'oggetto server
  ArduinoServer.begin();
}

void loop()
{
  //fai qualcosa!
  delay(10);
}

I commenti nel codice spiegano a grandi linee il funzionamento dello stesso. Dopo aver inserito le due librerie che permettono di interfacciarsi all’ethernet shield, definiamo due array di byte, uno che contiene l’indirizzo fisico della scheda di rete (MAC address) e l’altro che contiene l’indirizzo ip.

Successivamente ho creato un oggetto Server che permette di rimanere in ascolto sulla porta specificata, in questo caso la porta 80, proprio quella utilizzata dal protocollo http.

La variabile Data_RX verrà impiegata successivamente per memorizzare i byte provenienti dal client.

Dentro il blocco setup() ci sono due importanti funzioni, la prima (Ethernet.begin(mac, ip);) serve per inizializzare il chip WIZnet con l’indirizzo mac e l’indirizzo IP, la seconda (ArduinoServer.begin();) avvia il server e lo mette in ascolto sulla porta 80 per le avvenutali richieste dei client.

Nel blocco loop() ho inserito un ritardo di 10ms, per il momento non eseguiamo altro.

Questo codice è utile per verificare, tramite un semplice ping, se l’ethernet shield è correttamente configurata e se risponde alle interrogazioni dei client.

Apriamo una finestra dei prompt dei comandi (Start->Esegui->cmd.exe)

Digitiamo il comando ping seguito dall’indirizzo ip che abbiamo specificato nel codice dello skecth, nel mio caso:

ping 10.192.1.251

se i collegamenti sono corretti, e il codice viene caricato senza intoppi, otterremo la risposta della scheda come illustrato di seguito:

Questo semplice test ci permette di escludere problemi di alimentazione della board o errori doviti al cavo di collegamento.

Informazioni base su come configurare l’indirizzo ip

Certamente tutti voi sapete come configurare un indirizzo ip nella rete, ma penso sia necessario, per chi è alle prime armi, scrivere una piccola nota.
L’indirizzo ip identifica univocamente un dispositivo nella rete, probabilmente se utilizzate un router, questo assegnerà in modo automatico un indirizzo ad ogni dispositivo collegato (DHCP).

Per eseguire questi esperimenti dobbiamo disattivare il DHCP (sebbene sia possibile sfruttare questa funzione con Arduino ritengo, per semplicità, di non impiegarla) ed assegnare un indirizzo ip statico univoco ad ogni dispositivo della vostra rete.
Per fare ciò dovete andare nelle impostazioni del router e disattivare DHCP, poi per ogni pc della vostra rete, assegnate un indirizzo ip utilizzando le impostazioni della connessione di rete, tramite il pannello di controllo. Potete seguire questo link che mostra un video su come eseguire questa operazione

http://www.webip.info/cambiare_ip_windows_xp.php

Questo tutorial, invece, è per chi possiede Windows 7

Come Impostare un Indirizzo IP Statico su Windows

Ad esempio potremmo impostare il nostro pc con l’indirizzo 192.168.1.10 e la nostra Ethernet Shield con indirizzo 192.168.1.20

Come rispondere ai client

Una volta definiti gli indirizzi ip dei dispositivi della rete, possiamo iniziare a scrivere il codice che effettivamente risponde alle richieste dei client.
All’interno del blocco loop() bisogna creare un oggetto dalla classe Client, necessario ad ascoltare (listening) le richieste dei client.

L’idea di base è che il server aspetta la connessione di un client, controlla se ci sono dati da leggere e di conseguenza crea un oggetto Client.

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

La funzione ArduinoServer.available() non è bloccante quindi viene eseguita ciclicamente all’interno del blocco loop(), di conseguenza il valore restituito dalla funzione in mancanza di una richiesta client è false.

E’ necessario quindi controllare se l’oggetto pc_client istanziato sia diverso da false prima di poter instaurare la connessione.

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client != false)
{
  //se pc_client è true continuo ad utilizzarlo...
}

All’interno del blocco if utilizzo un ciclo while per eseguire il codice necessario a scambiare dati tra client e server fintanto che la connessione con il client è attiva

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è diverso da false
if (pc_client != false)
{
  //controllo se il client è connesso
  while (pc_client.connected())
  {
    //eseguo questo codice fintanto che il client è connesso...
  }
}

Riassumendo, quando la connessione è stabilita, Arduino esegue il codice all’interno del blocco while, questa è la parte più interessante perchè possiamo leggere e scrivere dati attraverso il protocollo di comunicazione http.

Continuiamo controllando se effettivamente ci sono byte da leggere impiegando la funzione read() dell’oggetto pc_client:

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client != false)
{
  //controllo continuamente che il client sia connesso
  while (pc_client.connected())
  {
    //Controllo se ci sono byte disponibili per la lettura
    if (pc_client.available())
    {
      //leggo i byte disponibili
      //provenienti dal client
      Data_RX = pc_client.read();
    }
  }
}

Ora eseguiamo un semplice test per verificare che il codice sin qui scritto funzioni.

Per avere un riscontro utilizziamo la classe Serial per inviare informazioni di debug tramite Serial Monitor. Inizializziamo, tramite Serial.Begin(9600), la porta seriale nel blocco setup().

Adesso posso controllare il contenuto della variabile Data_RX inviandoli al Serial Monitor.

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client != false)
{
  //controllo continuamente che il client sia connesso
  while (pc_client.connected())
  {
    //Controllo se ci sono byte disponibili per la lettura
    if (pc_client.available())
    {
      //leggo i byte disponibili
      //provenienti dal client
      Data_RX = pc_client.read();

      //invio i dati letti al Serial Monitor
      Serial.write(Data_RX);
    }
  }
}

Apriamo Serial Monitor con il relativo pulsante

Avviamo il nostro browser preferito, su un pc nella rete dove è collegato l’Arduino con Ethernet shield, e nella barra degli indirizzi digitiamo l’ip assegnato via codice all’ethernet shield.

Il browser eseguirà una richiesta GET che sarà elaborata dall’Arduino e visualizzata sul serial monitor.

Ecco il risultato:

Anche in questo caso questo semplice test ci da la conferma che il codice appena scritto funziona egregiamente.

Continuiamo ad aggiungere il codice di risposta che l’Arduino invierà al browser che ha effettuato la richiesta GET

//Ascolto le richieste dei client controllo se ci sono dati da leggere
//e creo un oggetto relativo a client che sta interrogando l'Ethernet shield
Client pc_client = ArduinoServer.available();

//controllo se pc_client è true
if (pc_client)
{
  //controllo continuamente che il client sia connesso
  while (pc_client.connected())
  {
    //Controllo se ci sono byte disponibili per la lettura
    if (pc_client.available())
    {
      //leggo i byte disponibili
      //provenienti dal client
      Data_RX = pc_client.read();

      //Attendo che tutti i byte siano letti
      //quando Data_RX contiene il carattere
      //di nuova line capisco tutti i byte sono
      //stati letti
      if (Data_RX == '\n')
      {
        //Invio la risposta al client
        //invio lo status code
        pc_client.println("HTTP/1.1 200 OK");
        //imposto il data type
        pc_client.println("Content-Type: text/html");
        pc_client.println();
        //invio codice html
        pc_client.print("<html><body><h1>");
        pc_client.print("Hello world Arduino Web Server</h1></body>   </html>");
        //aspetto 1 ms affinche la risposta giunga al browser del client
        delay(1);
        //esco dal ciclo while una volta completato l'invio della risposta
        break;
      }
    }
  }
  //chiudo la connessione
  pc_client.stop();
}

Verifico il valore di ogni byte letto, tramite l’istruzione if, fino a quando non ricevo un carattere di nuova linea \n (ox0A in esadecimale). Quando si verifica questa condizione la richiesta del client è stata letta completamente e quindi possiamo iniziare ad inviare la nostra risposta tramite la funzione println() dell’oggetto pc_client.

La prima stringa da inviare riguarda lo status code del protocollo http, composta dalla versione del protocollo http(HTTP/1.1) e dal codice 200 OK che specifica al client la corretta elaborazione dei dati.
La seconda stringa specifica il tipo di dati (http Content types) che stiamo inviando al client con il protocollo http.
Queste due stringhe costituiscono l’header della risposta http.

A questo punto inviamo la stringa con il codice html che compone la pagina che verrà inviata al browser sul client. Terminata anche questa operazione non ci resta che uscire dal blocco while con l’istruzione break, e terminare la chiusura della connessione con la funzione stop() per predisporci ad elaborare ulteriori richieste.

Nel prossimo articolo vedremmo come sfruttare gli ingressi analogici per acquisire dei segnali e i pin digitali per attivare dei led.

The post Arduino Ethernet Shield controllo remoto via web con http appeared first on Esperimenti con logiche programmabili.