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.

Esistono diverse librerie che tendono a risolvere o a migliorare alcune classi base implementate in Arduino 1.0. Webduino è sicuramente una di queste, il nome è un chiaro riferimento al mondo ethernet/web e le sue principali funzioni sono elencate di seguito:

• elaborazione dei parametri racchiusi in un URL
• elaborazione dei metodi HTTP come GET, POST, PUT, HEAD, DELETE e PATCH
• gestione dei FORM
• Gestione di Immagini
• interfaccia JSON/REST
• autenticazione BASE64

Attualmente, la versione disponibile è la 1.7  prelevabile direttamente da Github seguendo questo indirizzo https://github.com/sirleech/Webduino

Una volta scaricato il file zip possiamo scompattarlo posizionandolo all’interno della cartella libraries cercando di non modificare la struttura interna della cartella

Per eseguire il codice ho usato l’Arduino Ethernet, ma è possibile utilizzare benissimo la Arduino UNO con lo shield ethernet.

Passiamo direttamente alla pratica creando un nuovo sketch ed inserendo, per prima, le seguenti librerie

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

e subito di seguito le variabili e gli oggetti necessari al corretto funzionamento del modulo ethernet e della libreria Webduino:

[c]
//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);
[/c]

Il mac address e l’ip address sono definiti come per la libreria nativa Ethernet. L’oggetto webserver invece è relativo alla libreria Webduino ed accetta due parametri, il primo, che in questo caso è vuoto, permette di specificare un percorso (URL), mentre il secondo rappresenta la porta in cui il server rimarrà in ascolto.
Ad esempio potremmo avere :

[c]
//il web server risponde sulla porta 80 e richiama la root page /
WebServer webserver("", 80);
//il web server risponde sulla porta 80 e richiama la pagina digital.html
WebServer webserver("digital.html", 80);
//il web server risponde sulla porta 80 e richiama la pagina analog.html
WebServer webserver("analog.html", 80);
//il web server risponde sulla porta 8085 e richiama la root page predefinita
WebServer webserver("/test", 8085);
[/c]

qui devo fare una precisazione. le pagine specificare non sono in effetti come le conosciamo (codice html) ma sono dei riferimenti, delle stringhe, che richiamano funzioni contenenti codice html. Vedremo meglio negli esempi successivi cosa intendo.

Nel blocco setup inseriamo il codice per inizializzare gli oggetti dichiarati precedentemente e, con alcune istruzioni aggiuntive, permettiamo di elaborare le richieste provenienti dal browser

[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 (192.168.1.220/)
webserver.setDefaultCommand(&Start);

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

}
[/c]

il metodo setDefaultCommand permette di eseguire la funzione Start (inserita come parametro) in modo da elaborare la richiesta del browser.

All’interno del blocco loop bisogna inserire l’istruzione che ‘si accorge’ delle richieste del client e ne gestisce i relativi processi:

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

Per completare il codice, ed eseguire quindi un test operativo, scriviamo le istruzioni che compongono la funzione Start, che in questo esempio verrà eseguita come operazione di default quando un utente si collega al webserver semplicemente digitando nel browser l’indirizzo ip dell’Arduino.

[c]
//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 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);
}
}
[/c]

Il codice completo permette di eseguire, caricandolo nell’Arduino ethernet, il test della libreria

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

//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 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);
}
}

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]

Tramite il nostro browser preferito digitiamo l’indirizzo ip dell’Arduino; dovremmo visualizzare qualcosa del genere

Fatte diverse prove, modificando il codice, e leggendo i commenti per capire i vari passi da eseguire per iniziare ad usare la libreria Webduino. Nei prossimi articoli inseriremo alcune funzioni aggiuntive.

The post Utilizzare la libreria Webduino 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.

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.

Continuiamo l’articolo precedente inserendo nello sketch il codice che permette di campionare segnali analogici per poterli inviarli tramite protocollo http.
Utilizzando la funzione analogRead() acquisiamo il valore della tensione presente sul pin analogico, che verrà utilizzato per essere inserito nella pagina html da inviare al client. Con alcuni tag html aggiuntivi abbiamo la possibilità di avere un refresh automatico della pagina che ad intervalli regolari interrogherà il server Arduino, ottenendo automaticamente nuovi campionamenti del segnale analogico.
Il circuito seguente:

In questo esempio la tensione presente sul pin è fissa, ma nulla vieta l’inserimento di un potenziometro o meglio di un sensore analogico come la sonda di temperatura mcp9700a.

Il codice dello sketch rimane essenzialmente invariato tranne per l’inserimento di una variabile per contenere i valori provenienti dalla funzione analogRead() e di qualche riga html aggiuntiva per formattare la pagina:

if (Data_RX == '\n')
{
//campiono il valore di tensione analogia
//in ingresso sul pin0 ella borad Arduino UNO
analogIn0 = analogRead(0);
//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("");
pc_client.print("");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("");
pc_client.print("");
pc_client.print("

Valore analogico letto dal pin 0");
//inserisco nella pagina html il valore acquisito dal pin analogico
pc_client.print(analogIn0);
pc_client.print("

");
//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;
}

Non serve altro, è veramente semplice inviare via http i dati acquisiti dall’Arduino.
Possiamo certamente utilizzare anche gli altri ingressi analogici o come nel prossimo esempio leggere lo stato di alcuni pin digitali.
Per impiegare i pin digitali dobbiamo, nel blocco setup(),  specificare quali intendiamo utilizzare come ingressi. Per una semplice prova io ho usato il pin6 e il pin7:

void setup()
{
//inizializza lo shield con il mac e l'ip
Ethernet.begin(mac, ip);
//inizializza l'oggetto server
ArduinoServer.begin();
//definisco i pin6 e pin7 come ingressi
pinMode(6, INPUT);
pinMode(7, INPUT);
}

La funzione digitalRead() acquisisce il valore dello stato dei pin in esame e lo memorizza in una variabile precedentemente dichiarata. Questo valore viene successivamente inviato al client tramite la pagina html

if (Data_RX == '\n')
{
//leggo lo stato dei pin digitali 6 e 7
valPin6 = digitalRead(6);
valPin7 = digitalRead(7);

//campiono il valore di tensione analogia
//in ingresso sul pin0 ella borad Arduino UNO
analogIn0 = analogRead(0);

//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("");
pc_client.print("");
//questo codice html permette di eseguireil refresh automatico
//della pagina html
pc_client.print("");
pc_client.print("");
pc_client.print("

Valore analogico letto dal pin 0");
//inserisco nella pagina html il valore acquisito dal pin analogico
pc_client.print(analogIn0);
pc_client.print("

");

//inserisco nella pagina htm lo stato dei pin in ingresso
if(valPin6 == HIGH)
//se il valore è alto
pc_client.print("Stato pin6 = HIGH");
else
//se il valore è basso
pc_client.print("Stato pin6 = LOW");

pc_client.println("
");

if(valPin7 == HIGH)
//se il valore è alto
pc_client.print("Stato pin7 = HIGH");
else
//se il valore è basso
pc_client.print("Stato pin7 = LOW");

pc_client.print("");

//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;
}

Anche questo codice risulta semplice e i commenti che lo accompagnano descrivono bene le varie istruzioni. Dopo aver caricato lo sketch sull’Arduino ho messo il pin6 alla +5Vdc e il pin 7 a massa ottenendo il risultato seguente:

Naturalmente i pin 10-11-12-13, sono utilizzati per la comunicazioni SPI con l’ethernet shield e quindi, non possono essere impiegati per altri scopi senza interferire nella comunicazione stessa.

Vi rimando al prossimo articolo dove vedremo come utilizzare il browser per inviare comandi alla board Arduino, nel frattempo potete sperimentare con le nozioni acquisite per aumentare le vostre capacità nell’uso della athernet shield.

A presto!

The post Leggere dagli ingressi analogici da remoto con Arduino appeared first on Esperimenti con logiche programmabili.