Molti utenti che hanno realizzato il tutorial Scheda relè remota con Arduino e Webduino, dopo aver constatato il funzionamento del codice hanno poi implementato il codice per la gestione di ulteriori relè. A questo punto si sono accorti che il codice smette di funzionare e Arduino UNO sembra bloccata.
Tutto ciò avviene perché aggiungendo istruzioni contenenti stringhe ad un certo punto si arriva a saturare la memoria SRAM, questo è il motivo per cui la scheda va in blocco. La mancanza di memoria SRAM di fatto non permette di eseguire le istruzioni del nostro sketch.

Come è possibile risolvere il problema senza aumentare la memoria SRAM?

Sapiamo che la scheda possiede anche una memoria EEPROM da 1KB, e che tramite la funzione PROGMEM possiamo memorizzarci delle stringhe.

Anche la libreria Webduino permette di salvare e richiamare le stringhe dalla memoria EEPROM, quindi possiamo usare questa funzionalità per liberare SRAM e permettere la normale esecuzione del codice.

Vediamo come modificare una porzione del codice del precedente articolo:

[c]
if(Rele1 == true)
server.print(“<tr><td style=\”color: red;\”>RELE 1 ON</td><td>”);
else
server.print(“<tr><td style=\”color: black;\”>RELE 1 OFF</td><td>”);
[/c]

utilizzando le funzioni della libreria Webduino, per memorizzare le stringhe nella EEPROM

[c]
//memorizza le stringhe sulla EEPROM
P(str_rele1ON) = “<tr><td style=\”color: red;\”>RELE 1 ON</td><td>”;
P(str_rele1OFF) = “<tr><td style=\”color: black;\”>RELE 1 OFF</td><td>”;

if(Rele1 == true)
//richiama la stringa dalla eeprom
server.printP(str_rele1ON);
else
//richiama la stringa dalla eeprom
server.printP(str_rele1OFF);
[/c]

il codice precedente fa uso dell’istruzione P() e del metodo printP().

P() ha il compito di memorizzare la stringa nella EEPROM proprio come accade con l’istruzione PROGMEM. per richiamare la stringa è sufficiente richiamarla utilizzando il metodo printP() dell’oggetto server.

In definitiva se volete aggiungere più relè è sufficiente modificare il codice del tutorial come nell’esempio precedente.

The post Webduino scheda relè evitare blocco Arduino UNO appeared first on Esperimenti con logiche programmabili.

Tra le applicazioni che trovo molto richieste è la scheda relè da gestire tramite smartphone. Utilizzando la libreria Webduino riusciamo a realizzare un dispositivo semplice e funzionale basato su pochi componenti quali Arduino Ethernet, dei classici relè, un router wifi (presente ormai nelle nostre abitazioni) e uno smartphone.

La figura seguente illustra il progetto di questo articolo:

Arduino Ethernet è collegato tramite cavo lan al router e permette di gestire i relè collegati ai pin digitali tramite una applicazione web basata sulla libreria Webduino. Tramite lo smarthphone o un pc collegato alla rete locale possiamo gestire i relè semplicemente usando un browser web.

Per la parte software ho deciso di usare la libreria webduino perché fornisce tutto il necessario per la gestione delle richieste http.

Lo schema elettrico del prototipo che ho realizzato è il seguente:

Il codice caricato sul dispositivo è disponibile nel seguente listato:

[c]

#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino

//variabili statiche per il mac address e lìip address
static byte mac_Add[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = {
192, 168, 0, 220 };
//creazione oggetto Webduino
WebServer webserver("", 80);

//Variabili booleane che memorizzano
//lo stato delle uscite collegate ai relè
boolean Rele1 = false;
boolean Rele2 = false;
boolean Rele3 = false;

//=============================================================================
//funzione pagina Start
void Start(WebServer &server, WebServer::ConnectionType type,
char *url_param, bool param_complete)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
String s = "";

if (param_complete == true)
{
s = url_param;

if ( s == "R1=ON")
{
Rele1 = true;
digitalWrite(2, HIGH);
}
else if ( s == "R1=OFF")
{
Rele1 = false;
digitalWrite(2, LOW);
}

if ( s == "R2=ON")
{
Rele2 = true;
digitalWrite(3, HIGH);
}
else if ( s == "R2=OFF")
{
Rele2 = false;
digitalWrite(3, LOW);
}

if ( s == "R3=ON")
{
Rele3 = true;
digitalWrite(4, HIGH);
}
else if ( s == "R3=OFF")
{
Rele3 = false;
digitalWrite(4, LOW);
}
}

//gestisco la pagina html in base allo stato delle uscite di Arduino
P(htmlHead) =
"<html>"
"<head>"
"<title>Arduino Scheda Rele</title>"
"</head>"
"<body>";

server.printP(htmlHead);

server.print("<table border=\"1\">");
server.print("<tr><td>Stato Rele</td><td>Comandi</td></tr>");

if(Rele1 == true)
server.print("<tr><td style=\"color: red;\">RELE 1 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 1 OFF</td><td>");

if(Rele1 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R1=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R1=OFF’\">");

server.print("</td></tr>");

if(Rele2 == true)
server.print("<tr><td style=\"color: red;\">RELE 2 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 2 OFF</td><td>");

if(Rele2 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R2=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R2=OFF’\">");

server.print("</td></tr>");

if(Rele3 == true)
server.print("<tr><td style=\"color: red;\">RELE 3 ON</td><td>");
else
server.print("<tr><td style=\"color: black;\">RELE 3 OFF</td><td>");

if(Rele3 == false)
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R3=ON’\">");
else
server.print("<input type=\"button\" value=\"clicca qui\"
onclick=\"location.href=’index.htm?R3=OFF’\">");

server.print("</td></tr>");

server.print("</table></body></html>");

}
}
//=============================================================================

void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);

//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);
webserver.addCommand("index.htm", &Start);

//avvia il web server
webserver.begin();

delay(100);

//definisci i pin 2 3 4 in uscita
pinMode(2, OUTPUT);
pinMode(3, OUTPUT);
pinMode(4, OUTPUT);

//inizializza i le uscite
digitalWrite(2, LOW);
digitalWrite(3, LOW);
digitalWrite(4, LOW);

}

void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}

[/c]

Nonostante le numerose righe di codice potete capirne il funzionamento semplicemente leggendo i commenti che lo accompagnano.
L’interfaccia web per gestire i relè è la seguente:

Cliccando il bottone con la label “clicca qui” si ottiene una commutazione dello stato dei pin di uscita di Arduino e l’aggiornamento della label Stato Rele.

Anche in questo caso con poco si ottengono dispositivi interessanti e utili.

The post Scheda relè remota con Arduino e Webduino appeared first on Esperimenti con logiche programmabili.

Continuiamo a esplorare la libreria Webduino imparando a recuperare i parametri passati ad una pagina tramite l’indirizzo url. Questa possibilità ci permette di impartire comandi alla scheda Arduino usando appunto un indirizzo url. Ad esempio se colleghiamo due led, uno sul pin5 e uno sul pin6 potremmo scrivere qualcosa del genere per accendere o spegnere i led

http://192.168.1.100/index.html?LED5=ON (Accende il led collegato al pin5)

http://192.168.1.100/index.html?LED5=OFF (Spegne il led collegato al pin5)

http://192.168.1.100/index.html?LED6=ON (Accende il led collegato al pin6)

http://192.168.1.100/index.html?LED6=OFF (Spegne il led collegato al pin6)

dove 192.168.1.100 è l’indirizzo della Arduino Ethernet

Il codice seguente inizializza la libreria, crea la pagina di default e la pagina index.htm.

[c]
#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino&lt;/code&gt;

//variabili statiche per il mac address e l’ip address
static byte mac_Add[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = { 192, 168, 1, 220 };
//creazione oggetto Webduino
WebServer webserver("", 80);
//funzione Start
void Start(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();
//gestisco il tipo di richiesta GET
if (type == WebServer::GET)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Logicaprogrammabile</h1>";
//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}

void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);
//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);
//avvia il web server
webserver.begin();
}

void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}
[/c]

Per recuperare i dati passati come argomento all’url dobbiamo modificare la funzione Start() utilizzando il terzo e il quarto argomento; modifichiamo la funzione in questo modo:

[c]
//funzione Start
void Start(WebServer &server, WebServer::ConnectionType type,
char *url_param, bool param_complete)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();
P(strMsg) = "<h1>Logicaprogrammabile</h1>";
//Gestisco la richiesta GET
if (type == WebServer::GET)
{
server.printP(strMsg);
}
}
[/c]

url_param conterrà l’argomento passato all’indirizzo url. Proviamo a modificare il codice della funzione Strat()

[c]
//funzione Start
void Start(WebServer &server, WebServer::ConnectionType type,
char *url_param, bool param_complete)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();
 P(strMsg) = "<h1>Logicaprogrammabile</h1>";
//Gestisco la richiesta GET
if (type == WebServer::GET)
{
server.printP(strMsg);
//se il parametro è disponibile
if (param_complete == true)
{
//restituiscine il valore del parametro
server.print(url_param);
}
}
}
[/c]

Purtroppo non è possibile gestire parametri multipli, quindi un url scritto in questo modo

http://192.168.1.100/index.html?LED6=OFF&LED5=ON

produrrà questo risultato

LED6=OFF&LED5=ON

Per ottenere le informazioni che ci interessano, possiamo usare la funzione indexOf della classe String, quindi dopo aver recuperato la stringa dei parametri dobbiamo assegnarla ad una variabile String ed eseguire una piccola elaborazione per ottenere i valori che ci interessano

[c]
#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino&lt;/code&gt;
//variabili statiche per il mac address e l’ip address
static byte mac_Add[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = { 192, 168, 1, 210 };
//creazione oggetto Webduino
WebServer webserver("", 80);
//funzione Start
void Start(WebServer &server, WebServer::ConnectionType type,
char *url_param, bool param_complete)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();
P(strMsg) = "<h1>Logicaprogrammabile</h1>";
//Gestisco la richiesta GET
if (type == WebServer::GET)
{
server.printP(strMsg);</p>
//se il parametro è disponibile
if (param_complete == true)
{
//passo i parametri ad una stringa
String parametri = url_param;
//ricerco nella stringa i valori che mi interessano
int Led5 = parametri.indexOf("LED5=ON");
int Led6 = parametri.indexOf("LED6=ON");
if (Led5 >= 0)
{
//ho trovato la stringa
//commuto la porta 5 a livello alto
digitalWrite(5, HIGH);
}
else
digitalWrite(5, LOW);
if (Led6 >= 0)
{
//ho trovato la stringa
//commuto la porta 5 a livello alto
digitalWrite(6, HIGH);
}
else
digitalWrite(6, LOW);
//restituiscine il valore
server.print(url_param);
}
}
}
void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);
//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);
//aggiungi una pagina
webserver.addCommand("index.htm", &Start);
//avvia il web server
webserver.begin();
//imposto il pin 5 e 6 in uscita
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
}
void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}
[/c]

Anche se il codice sembra complesso, basta dedicargli qualche minuto per capire che tutto è molto semplice e veloce.

The post Webduino recuperare parametri da un URL appeared first on Esperimenti con logiche programmabili.

Nel precedente articolo hai visto come installare la libreria webduino e come creare la tua prima pagina. In questo secondo articolo produrrai altre pagine utilizzando le funzioni messe a disposizione della libreria e vedrai come sia semplice costruire una struttura tipica di un sito web.

Anche in questo caso le pagine non sono intese come file html, ma bensì come una funzione che genera il codice htm.

Per aggiungerle è sufficiente usare il metodo addCommand() dell’oggetto webserver.

Il codice seguente illustra come sia possibile realizzare quanto descritto:

[c]
void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);

//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);

//aggiungi altri comandi/pagine
webserver.addCommand("Page01", &CmdPage01);
webserver.addCommand("Page02", &CmdPage02);

//avvia il web server
webserver.begin();
}
[/c]

Le pagine/funzioni vengono definite nel blocco setup() subito la funzione setDefaultCommand(). I parametri da passare sono il nome che verrà scritto nell’url e il puntatore alla funzione che elaborerà la richiesta proveniente dal brovser.
In questo caso gli url saranno così definiti:

IndirizzoIParduino/Page01
IndirizzoIParduino/Page02

Inviando il primo indirizzo verrà eseguita la funzione con nome CmdPage01, e con il secondo indirizzo verrà eseguita la funzione con nome CmdPage02.

Nel codice dello sketch definiamo le due funzioni che conterranno un titolo ed un link per ritornare alla home page

[c]
void CmdPage01(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Pagina 01</h1>"
"<a href=’\’>Home</a>";

//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}

void CmdPage02(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Pagina 02</h1>"
"<a href=’\’>Home</a>";

//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}
[/c]

E’ possibile inserire diverse pagine per formare una struttura di pagine, anche complessa. L’unico limite è la memoria del chip Atmega che può essere integrata utilizzando una microSD, disponibile sia sul modulo ethernet shield sia sulla Arduino Ethernet.

Di seguito il codice integrale dello sketch cosi da poter provare subito l’esempio:

[c]
#include <Ethernet.h>
#include <SPI.h>
#include <WebServer.h> //libreria webduino

//variabili statiche per il mac address e lìip address
static byte mac_Add[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
//cambiare l’ip in funzione della propria rete
static byte ip_Add[] = { 192, 168, 1, 220 };
//creazione oggetto Webduino
WebServer webserver("", 80);

//=============================================================================
//funzione pagina Start
void Start(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Logicaprogrammabile</h1>";

//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}
//=============================================================================
//funzione pagina Start
void CmdPage01(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Pagina 01</h1>"
"<a href=’\’>Home</a>";

//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}
//=============================================================================
//funzione pagina Page02
void CmdPage02(WebServer &server, WebServer::ConnectionType type, char *, bool)
{
//restituisce al browser l’intestazione http 200 OK
server.httpSuccess();

//gestisco il tipo di richiesta HEAD
if (type != WebServer::HEAD)
{
//Memorizzo nella memoria programma la stringa html e gli assegno il nome strMsg
P(strMsg) = "<h1>Pagina 02</h1>"
"<a href=’\’>Home</a>";

//recupero dalla memoria programma la stringa contrassegnata con il nome strMsg
//e la invio come output al browser
server.printP(strMsg);
}
}
//=============================================================================
void setup()
{
//inizializzo l’ethernet shield con il mac e il address
Ethernet.begin(mac_Add, ip_Add);

//definisci l’azione di default che verrà eseguita quando l’utente
//naviga nella root del sito
webserver.setDefaultCommand(&Start);

//aggiungi altri comandi/pagine
webserver.addCommand("Page01", &CmdPage02);
webserver.addCommand("Page02", &CmdPage01);

//avvia il web server
webserver.begin();
}

void loop()
{
//elabora costantemente tutte le richieste provenienti dal browser
webserver.processConnection();
}
[/c]

The post Webduino aggiungere pagine web 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.