La libreria Webduino implementa una semplice autenticazione basata sul protocollo http. Certamente non offre un livello di sicurezza impenetrabile ma può comunque essere utile utilizzare questa funzione per le nostre applicazioni.

Nell’esempio, viene caricata la pagina index.htm dove è presente un link che punta a una pagina protetta. per poter visualizzarne il contenuto è necessario inserire nome utente e password.

La based authentication si basa sulla codifica Base64. Il nume utente e la password, nella forma numeutente:password, vengono convertiti in un unica stringa  di caratteri.  Per la conversione, potete utilizzare diversi servizi online oppure scaricare la mia app ConvertBase64.

Il codice seguente è pronto all’uso, dovete cambiare solamente l’indirizzo ip, adattando lo alla vostra rete locale.

[c]
#include "SPI.h"
#include "Ethernet.h"
#include "WebServer.h"

//definisco mac address e indirizzo ip
static uint8_t mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
static uint8_t ip[] = { 192, 168, 1, 10};

//creo un oggetto webduino
WebServer webserver("", 80);

//funzione che crea la pagina principale del sito
void defaultCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
server.httpSuccess();
if (type != WebServer::HEAD)
{
//invio al browser la pagina principale
P(helloMsg) = "<h4>Accedi:</h4><a href=\"private.html\">Pagina Privata</a>";
server.printP(helloMsg);
}
}

//questa funzione permette di verificare il nome utente e la password
//e in caso di successo di visualizzare la pagina privata
void privateCmd(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//user= admin
//password= admin

//verifico nome utente e password
if (server.checkCredentials("YWRtaW46YWRtaW4="))
{
//in caso affermativo…
server.httpSuccess();
if (type != WebServer::HEAD)
{
//invio al browser la pagina privata
P(helloMsg) = "<h3>Buongiorno Admin!</h3>";
server.printP(helloMsg);
}
}
else
{
//creo una risposta http
//nel caso in cui si tenta un accesso
//no autorizzato
server.httpUnauthorized();
}
}

void setup()
{
//inizializzo la ethernet shield
Ethernet.begin(mac, ip);
//definisco funzione che gestisce
//la pagina principale del sito
webserver.setDefaultCommand(&defaultCmd);
webserver.addCommand("index.html", &defaultCmd);
//definisco la funzione che gestisce la pagina privata
webserver.addCommand("private.html", &privateCmd);

//inizializzo la libreria webduino
webserver.begin();
}

void loop()
{
char buff[64];
int len = 64;

webserver.processConnection(buff, &len);
}
[/c]

La libreria Webduino è molto flessibile e permette di realizzare applicazioni interessanti in modo molto veloce.

The post Webduino Based Authentication. Accedere ad una pagina privata appeared first on Esperimenti con logiche programmabili.

Quando utilizziamo Arduino Ethernet (o EthernetShield) in modalità webserver, non è disponibile una funzione nativa che permetta di visualizzare una immagine nella pagina web generata da Arduino. Esiste però un metodo molto semplice che permette di visualizzare delle immagini, di piccole dimensioni, utilizzando la codifica Base64.

L’idea è quella di utilizzare una stringa che codifica un file immagine, da inserire nello sketch. Diversi siti web offrono un convertitore online che codifica un file immagine (jpg, gif o png) in una stringa equivalente in standard Base64.
Per questo tutorial ho utilizzato il servizio di webcodertools.com disponibile a questo indirizzo. Basta caricare un file immagine per ottenere direttamente una stringa Base64 con in aggiunta il tag html img.

Ad esempi questo file immagine png :

viene convertito nella seguente stringa

<img alt="" src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAABWklEQVQ4ja1TMUvDQBT+7iztWsSlHZLJZigFC12FiINzx26SKVtnHcxlcXcyixEnR107FPIDChXEoTpoMrRLkYIuLdjnYO+4tA1Y8YPj4H3v+97du3eMiKBj69SrzA2zBUAgDcGT+Pbr3H/Wg0w3YEHorREuQ5Dr+CsGLAgpU7IG5DoMALhWeSNIDeMnZ5W5YQ4AYG9nG8V8AZPZFA/j95RgHceT2MotGobrg30cW7tKEA1HaHa6AIC7o0PY5ZLi7l9jNDtdzA2zxXB5RaJRh9eogwWhfkdEwxEAwC6XVji/14fo9X960K5VUwmLO8Iul1Jich3FtWtVqCYWC3mVINcyZEzuUpMDgLePT+WcBRaEINdROZPpTJ1A3AxeVqrKHkTDUerokrt4fAIAoZ7xL6/Ak9hiRKRGeMM5EOQ6/v+MshYQv9AKKU4ZLEx8nsRWhpHgSWzpPxEAvgHST7pu8mrutQAAAABJRU5ErkJggg==" />

mentre il codice seguente è uno sketch webserver che crea una pagina html con l’immagine codificata:

[c]
/*
Semplice Controllo remoto
Gennaio 2012
Marco Lai
*/

//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[] = {xxx, xxx, xxx, xxx}; //modificate questo valore in base alla vostra rete

char Data_RX;

//creao un oggetto server che rimane in ascolto sulla porta
//specificata
EthernetServer 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()
{
EthernetClient 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();

//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>");
pc_client.print("<head>");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("<META HTTP-EQUIV=’refresh’ CONTENT=’5; /’>");
pc_client.print("</head>");

pc_client.print("Arduino visualizza l’immagine ");
pc_client.print("<img alt=\"\" src=\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAABWklEQVQ4ja1TMUvDQBT+7iztWsSlHZLJZigFC12FiINzx26SKVtnHcxlcXcyixEnR107FPIDChXEoTpoMrRLkYIuLdjnYO+4tA1Y8YPj4H3v+97du3eMiKBj69SrzA2zBUAgDcGT+Pbr3H/Wg0w3YEHorREuQ5Dr+CsGLAgpU7IG5DoMALhWeSNIDeMnZ5W5YQ4AYG9nG8V8AZPZFA/j95RgHceT2MotGobrg30cW7tKEA1HaHa6AIC7o0PY5ZLi7l9jNDtdzA2zxXB5RaJRh9eogwWhfkdEwxEAwC6XVji/14fo9X960K5VUwmLO8Iul1Jich3FtWtVqCYWC3mVINcyZEzuUpMDgLePT+WcBRaEINdROZPpTJ1A3AxeVqrKHkTDUerokrt4fAIAoZ7xL6/Ak9hiRKRGeMM5EOQ6/v+MshYQv9AKKU4ZLEx8nsRWhpHgSWzpPxEAvgHST7pu8mrutQAAAABJRU5ErkJggg==\" />");

pc_client.print("</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();
}
}

[/c]

Con questo metodo sarà più semplice creare pagine html più accattivanti utilizzando codice html e immagini codificate in Base64.
L’unica limitazione sta nella dimensione dell’immagine, infatti con un file grande otterremo una stringa enorme, saturando cosi la memoria dell’Arduino, in questo caso però potremmo utilizzare la memoria microSD.

The post Visualizzare immagini con un Webserver Arduino appeared first on Esperimenti con logiche programmabili.

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.