Inviare dati a PHP e ricevere comandi via HTTP in un unica sessione

Detto fatto!!! :slight_smile:
Non so come ringraziarti e una mano o una dritta è ben gradita.
Come puoi immaginare la versione è ALPHAissima, ma come ogni buon tinkerer che si rispetti ho cercato di commentare il più possibile.
Spero che sia chiaro.

#include <String.h>
#include <SPI.h>
#include <Ethernet.h>

#include <Client.h>
#include <Server.h>

/* ***
controllare un attuatore via web e salvare dati in DB
con sensori di temperatura, luce e interruttore magnetico
ARDUINO UNO
ETHERNET SHIELD
*** */

/inizializzazione ethernet shield/

byte mac[] = {
0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = {
192, 168, 0, 100 }; // ip arduino internet in ***
byte gateway[] = {
192, 168, 0, 1 };
byte subnet[] = {
255, 255, 255, 0 };
byte server[] = {
000, 000, 000, 000 }; // server a cui inviare dati
Client client(server, 80); //porta del client server

/FINE inizializzazione ethernet shield/

long ContaCicli = 0; // contatore di loop

int outPinRele = 9; // pin attuatore
//char link[]="http://www.giannifavilli.it"; //link
String leggoStringa; // string del MAC in arrivo

boolean RELE1ON = false; // flag status attuatore RELE1ON
boolean logIn = false; // flag status attuatore logIn

/termistore/
float Temp; // variabile da calcolare
float inTemp = 1; // pin analogico IN temperature sensor
int ledPinTemp = 6; // pin led termistore
float TempReg = 20.0; // temperatura di controllo in celsius
/end termistore/

/fotoresistore/
int Lux; // variabile da calcolare
int ledPinLux = 7; // pin led fotoresistenza
int inPhotoresistor = 0; // pin analogico IN fotoresistore
float LuxReg = 150; // valore controllo luce da 0 a 255
/end fotoresistore/

/* interruttore allarme a contatto magnetico*/
int ledPinSwitch = 8; // scelgo il pin per il led interruttore
int inSwitch = 2; // scelgo il pin DIGITALE per l'interruttore
int valSwitch = 0; // variabile per leggere lo stato del pin
/* end interruttore allarme a contatto magnetico*/

/imposto la variabile e scrivo la stringa POST/
void inviaDataServer (Client c) {

c.print("POST http://000.000.000.000/arduino/listener.inc.php?cod=3&"); // indirizzo del server dove gira PHP
c.print("temp=");
c.print(Temp);
c.print("&");
c.print("lux=");
c.print(Lux);
c.print("&");
c.print("swt=");
c.print(valSwitch);
c.print("&");
c.print("Server=NOMESERVER");
c.print("&");
c.print("Board=ArduinoUNO");
c.print("&");
c.print("Cicli=");
c.println(ContaCicli);
}

void setup()
{
//delay(10000);
Ethernet.begin(mac, ip, gateway, subnet);
pinMode(outPinRele, OUTPUT); // dichiaro l'output del rele
pinMode(ledPinLux, OUTPUT); // dichiaro l'output delled lux
pinMode(ledPinTemp, OUTPUT); // dichiaro l'output della Temp
pinMode(ledPinSwitch, OUTPUT); // dichiaro l'output del led interruttore
pinMode(inSwitch, INPUT); // dichiaro l'input dell'interruttore
Serial.begin(9600);
Serial.println("connecting...");
}

void loop()
{
ContaCicli = ContaCicli++;

/inizio calcolo temperatura/
Temp = ((5 * analogRead(inTemp) * 100.0 ) / 1024) - 50;
/fine calcolo temperatura/

/inizio calcolo luce/
Lux = analogRead(inPhotoresistor);
Lux = constrain(Lux, 0, 1023); // limiti dei valori tra 0 e 1023
Lux = map(Lux, 0, LuxReg, 255, 0);
/fine clacolo luce/

/inizio clacolo switch/
valSwitch = digitalRead(inSwitch); // legge il valore dell'input switch
/fine clacolo switch/

if (client.connect()) {

inviaDataServer(client);
Serial.println("Connesso -> Valori Inviati");

// receiviDataServer(client);
// Serial.println("Connesso -> Valori Ricevuti");

/inizio client/
if (client) {
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
leggoStringa.concat(c);
if (c == '\n' && currentLineIsBlank) {
Serial.print(leggoStringa);
/imposto una stringa di controllo/
if(leggoStringa.indexOf("User=nome&Pwd=password") > 0) {
logIn=true;
}
else {
logIn=false;
}
if(logIn == true){
/inizio controllo attivazione del rele RELE1ON/
if(leggoStringa.indexOf("&OUT=11") > 0) {// check per attivare outPinRele
//led ON
digitalWrite(outPinRele, HIGH); // outPinRele ON
RELE1ON = true;
// *** //Serial.print("ON pin "); // scrivo in console il valore
// *** //Serial.println(outPinRele); // scrivo in console il valore
}
else
if(leggoStringa.indexOf("&OUT=01") > 0) // check per disattivare outPinRele
{
//led OFF
digitalWrite(outPinRele, LOW); // outPinRele OFF
RELE1ON = false;
// *** //Serial.print("OFF pin "); // scrivo in console il valore
// *** //Serial.println(outPinRele); // scrivo in console il valore
}
/fine controllo attivazione del rele RELE1ON/
}
} // FINE if client

}
else {
Serial.println("Connessione Fallita -> Impossbile Inviare/Ricevere Dati");
}
// pulisco la stringa per la successiva lettura
leggoStringa="";
//fermo il client
client.stop();
delay(10000);
} // FINEif client disponibile
}// FINEwhile client connesso
}// FINE if client
} // FINE loop

Ciao e ancora grazie,
Gianni

Ciao,

gli ho dato un primo sguardo al volo.

Non ho ben capito capito se l'attivazione del rele' e' nella risposta che ricevi dal server remoto (quello su cui gira il webserver con PHP) in seguito alla richiesta dei dati data dalla funzione inviaDataServer, oppure vuoi che da un un pc qualsiasi si faccia una richiesta direttamente all'Arduino (meglio dire all'IP pubblico del gateway (router ADSL) che poi fa la richiesta all'indirizzo e porta dell'Arduino nella rete privata).

Ad ogni modo ecco alcune cose che cambierei

Utilizzerei, vista la quantita' dei dati da inviare, il GET al posto del POST per l'invio dei dati.
Nel codice PHP cambi i $_POST con $_GET.

void inviaDataServer (Client c) {
  c.print("POST http://000.000.000.000/arduino/listener.inc.php?cod=3&"); // indirizzo del server dove gira PHP

diventerebbe

c.print("GET /arduino/listener.inc.php?cod=3&");
...
c.print(" HTTP 1.0");

Allla fine andrebbe inserito il protocollo di trqasmissione che vuoi utilizzare.
Guardati le differenze fra HTTP 1.0 e HTTP 1.1

Anche se utilizzi HTTP 1.1 e lasci la connessione aperta hai sempre a che vedere con eventuali disconnessioni da timeout o per altre ragioni.
Va quindi inserito un meccanismo per la riconnessione nel codice.

La parte a partire da

/*inizio client*/
    if (client) {
      boolean currentLineIsBlank = true;
      while (client.connected()) {
        if (client.available()) {
          char c = client.read();
          leggoStringa.concat(c);
  ....

va rivista in funzione se e' nella risposta all'invio dei dati che vi e' il comando di accensione o meno del rele'.

Io scinderei le due cose.

Se vuoi fare tutto interrogando sempre il webserver PHP allora:

  • Farei una richiesta al server PHP per inviare i dati e controllerei se va a buon fine.
  • Poi farei un'altra richiesta ad altro file per sapere se vi e' richiesta di attivazione rele'.

Spero di essermi spiegato, piu' tardi posso vedere meglio il tutto, ora devo finire del codice PHP.

Ciao,
Marco.

ah ok, vuoi un server ce gestisca più client contemporaneamente http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238640832, se vuoi che possa gestire più richieste (non di contemporaneamente), allora basta che dopo il client.stop(), o quando rilevi il client disconnesso & non in ascolto, lo rimetti in ascolto.

Provo a rispondere.

Non ho ben capito capito se l'attivazione del rele' e' nella risposta che ricevi dal server remoto (quello su cui gira il webserver con PHP) in seguito alla richiesta dei dati data dalla funzione inviaDataServer, oppure vuoi che da un un pc qualsiasi si faccia una richiesta direttamente all'Arduino (meglio dire all'IP pubblico del gateway (router ADSL) che poi fa la richiesta all'indirizzo e porta dell'Arduino nella rete privata).

La richiesta per l'attivazione del relè deve arrivare dal server dove gira PHP è più sicuro da un punto di vista informatico.

Utilzzando il GET

c.print("GET http://www.mioserverphp/arduino/listener.inc.php?cod=3&");
...
c.print(" HTTP 1.0");

Ho provato ad inserire HTTP 1.0 o 1.1 e non invia i dati ... ma lo correggo come minimo sbaglio qualche spazio. Grazie della dritta del GET al posto del POST.

Se vuoi fare tutto interrogando sempre il webserver PHP allora:

  • Farei una richiesta al server PHP per inviare i dati e controllerei se va a buon fine.
  • Poi farei un'altra richiesta ad altro file per sapere se vi e' richiesta di attivazione rele'.

E' un eccellente soluzione.

ah ok, vuoi un server ce gestisca più client contemporaneamente http://www.arduino.cc/cgi-bin/yabb2/YaBB.pl?num=1238640832, se vuoi che possa gestire più richieste (non di contemporaneamente), allora basta che dopo il client.stop(), o quando rilevi il client disconnesso & non in ascolto, lo rimetti in ascolto.

Sì, mi sono spiegato male a dire in contemporanea ... sì l'idea è che Arduino manda i valori al server PHP e connettendomi a quest'ultimo tramite un form mando una stringa ad Arduino che la legge e la interpreta.
Comunque la soluzine che mi dai di rimettere in ascolto Arduino dopo l'invio del GET seguito dal client.stop() non mi era mai balenta nell testa e mi sembra eccellente.

Non sò ancora come ringraziarvi ... provo a fare dei test e vi aggiorno.

Ciao,
Gianni

ah ok, ora mi è tutto più chiaro.
quindi arduino è un client, se fai che appena chiudi la connessione si riapre, avrai arduino che contina a richiedere pagine al tuo server HTTP, creando in pratica un simil attacco dos... metti un pò di tempo di attesa. (come il delay che c'è già dopo client.stop() )

ah HTTP 1.0 non ti funziona perchjè la sintassi corretta è:

GET /index.html HTTP/1.1
Host: www.example.com

Ciao a tutti,
scusate la latitanza ma il mare chiamava :slight_smile:
Ho ripreso a lavorare sul progetto e ho sviluppato la parte PHP che rimane in attesa di ricevere i dati da arduino, fin qui tutto bene. Purtroppo non riesco ancora a far leggere ad Arduino la stringa indexOf che arrvia da un browser o direttamente dalla pagina PHP che rimane in attesa di un determinato evento.

Se vuoi fare tutto interrogando sempre il webserver PHP allora:

  • Farei una richiesta al server PHP per inviare i dati e controllerei se va a buon fine.
  • Poi farei un'altra richiesta ad altro file per sapere se vi e' richiesta di attivazione rele'.

Marco, non ho capito bene il secondo punto. La parte di invio dati funziona ed è come la volevo, addirittura usando le notifiche di Google Calendar riesco a ricevere degli SMS nel caso avvenga un determinato evento su Arduino.
Il mio problema "insormontabile" rimane il fatto che non riesco a far leggere ad arduino una stringa che gli dovrebbe arrivare come un indirizzo o meglio un MAC del tipo http://indirizzo-arduino/?LUCE=ON
Posto nuovamente il codice all'ultima versione sperando che voi più esperti riuscite a capire dove sbaglio o se faccio confusione io.

#include <String.h>
#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //physical mac address
byte ip[] = { 
  192, 168, xxx, xxx }; // ip arduino internet in ***
byte gateway[] = { 
  192, 168, xxx, xxx }; // internet access via router ***
byte subnet[] = { 
  255, 255, xxx, xxx }; //subnet mask ***
byte server[] = { xxx, xxx, xxx, xxx }; // server a cui inviare dati
Client client(server, 80); //client server port

...

/*imposto la variabile e scrivo la stringa GET*/
void inviaDataServer (Client c) {

          c.print("GET /listener.php?test=p25&");
...
          client.println(" HTTP/1.1");
          client.println("Host:xxx.xxx.xxx.xxx");
          client.println(); 
}

void setup()
{
  Ethernet.begin(mac, ip, gateway, subnet);
...
  Serial.begin(9600);
  Serial.println("connecting...");
}

void loop()
{

...
  
if (client.connect()) {

//     inviaDataServer(client);
     Serial.println("Connesso -> Valori Inviati");

/*** DA QUI IN POI IL CAOS ***/
/*** Le parti di "CAOS" remmate sono le varie prove che ho eseguito 
per far leggere ad Arduino la stringa in arrivo ma senza successo!***/
//if (client) {
//  while (client.connected()) {
//    if (client.available()) {

while (client.available()) {
      char s = client.read();
        leggoStringa.concat(s); 
       if (s == '\n' && currentLineIsBlank) {
         Serial.print(leggoStringa);
        if(leggoStringa.indexOf("LUCE=ON") > 0) {
          digitalWrite(outPinRele, HIGH); 
          LEDON = true;
          }else{
          digitalWrite(outPinRele, LOW);
          LEDON = false; 
        }
        } //if (s == '\n' && currentLineIsBlank)	
} //while (client.available())
//}	//if (client.available())
//}	//while
//}   //if (client)
} else { 
Serial.println("Connessione Fallita -> Impossbile INVIARE Dati");
}
        //fermo il client
        client.stop();
        delay(5000);
} // FINE loop

Spero in un vostro cortese aiuto.
Ciao a tutti,
Gianni

il tuo arduino fa da client è invia la richesta GET, il server NON risponde con una GET ma con un messaggio di OK.

allora per capire cosa stai combinando anche a lato PHP fai così:

#include <String.h>
#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; //physical mac address
byte ip[] = { 
  192, 168, xxx, xxx }; // ip arduino internet in ***
byte gateway[] = { 
  192, 168, xxx, xxx }; // internet access via router ***
byte subnet[] = { 
  255, 255, xxx, xxx }; //subnet mask ***
byte server[] = { xxx, xxx, xxx, xxx }; // server a cui inviare dati
Client client(server, 80); //client server port

...

/*imposto la variabile e scrivo la stringa GET*/
void inviaDataServer (Client c) {

          c.print("GET /listener.php?test=p25&");
...
          client.println(" HTTP/1.1");
          client.println("Host:xxx.xxx.xxx.xxx");
          client.println(); 
}

void setup()
{
  Ethernet.begin(mac, ip, gateway, subnet);
...
  Serial.begin(9600);
  Serial.println("connecting...");
}

void loop()
{

...
  
if (client.connect()) {

//     inviaDataServer(client);
     Serial.println("Connesso -> Valori Inviati");

/*** DA QUI IN POI NON FUNZIONA ***/

if (client) {

Serial.println("Inizio lettura:");

while (client.available()) {
      char s = client.read();
       Serial.print(leggoStringa);
} //while (client.available())

Serial.println();
Serial.println();

}   //if (client)
} else { 
Serial.println("Connessione Fallita -> Impossbile INVIARE Dati");
}
        //fermo il client
        client.stop();
        delay(5000);
} // FINE loop

Grazie lesto della risposta!
Il PHP può rispondere in due maniera, manuale con un FORM in HTML o in automatico.
Ho utilizzato il tuo esempio ma non ricevo nessuna risposta ... :frowning:
Il codice PHP che mi deve rispondere per fare un esempio molto semplice è questo.

header ("Location: http://indirizzo-arduino/?LEDON");

Ma non funziona!!!
Nell'inizializzazione del codice di Arduino la variabile leggoStringa messa così:
String leggoStringa; // stringa

Mentre se aggiungo al codice: leggoStringa.concat(s);

while (client.available()) {
      char s = client.read();
      leggoStringa.concat(s);
      Serial.print(leggoStringa);
} //while (client.available())

Ricevo delle risposte ma non belle :frowning: tipo HTTP 302 Found come se PHP non riuscisse ad eseguire il redirect.

ehmmm... veramente l'errore 302 è proprio quello che indica che la pagina è stata spostata, ed include anche il link alla nuova pagina (la famosa location)
secondo me in PHP NON devi restituire una location, o un URL, ti complichi solo la vita. Fagli rispondere una normale pagina HTML con tutti i dati che ti serve inviare all'arduino

Grazie ancora lesto dei tuoi consigli molto utili.
Sono riuscito a fere quello che volevo ma ho dovuto utilizzare delle "toppe" e ho dovuto far fare ad arduino la costruzione dell'html, una cosa che volevo evitare che facesse lui. Nel mio progetto arduino doveva solo leggere una stringa e non doveva oberarsi di costruire anche l'html ma provando e riprovando non ci sono riuscito.
Il progetto al momento è molto Alpha comunque Arduino riceve delle chiamate in ingresso sotto forma di stringhe http e invia un get con un report dei vari sensori ad una pagina php che elabora i dati.
C'erano degli errori nei codici postati in precedenza.
Inanzitutto l'inizializzazione ... questa che segue è la corretta:

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, xxx, xxx };
byte gateway[] = { 192, 168, xxx, xxx };
byte subnet[] = {  255, 255, xxx, 0 }; 
byte serverphp[] = { xxx, xxx, xxx, xxx }; // indirizzo ip del server a cui inviare dati
Server server(80); //porta del server

Quindi il risultato finale è il seguente, ripeto che è molto Alpha come versione tra qualche giorno vi posterò quella definitiva e testata ad utilizzo della community

#include <String.h>
#include <SPI.h>
#include <Ethernet.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };
byte ip[] = { 192, 168, xxx, xxx };
byte gateway[] = { 192, 168, xxx, xxx };
byte subnet[] = {  255, 255, xxx, 0 }; 
byte serverphp[] = { xxx, xxx, xxx, xxx }; // indirizzo ip del server a cui inviare dati
Server server(80); //porta del server

...

void setup()
{
  Ethernet.begin(mac, ip, gateway, subnet);
...
  Serial.begin(9600);
  Serial.println("connecting...");
}

void loop()
{

...
  
/*parte che riceve i dati*/
Client client = server.available();

if (client) {
  boolean currentLineIsBlank = true;
  while (client.connected()) {
    if (client.available()) {
      char c = client.read();
        leggoStringa.concat(c);
      if (c == '\n' && currentLineIsBlank) {
         Serial.print(leggoStringa);
        if(leggoStringa.indexOf("qualcosa") > 0) {
          Serial.println("ON");
        
          }else{
          Serial.println("OFF");
        }
        //costruzione html
        client.println("HTTP/1.1 200 OK");
        client.println("Content-Type: text/html");
        client.println();
        // inizializzo pagina
        client.print("<html><head><title>ARDUINO WEB TEST</title><meta http-equiv='Content-Type' content='text/html; charset=iso-8859-1' ></head><body>");
        ...
        client.println("</body></html>");
        
        //pulisco la stringa
        leggoStringa="";
        //fermo il client
        client.stop();

        } //if c == /n
    } // if client available
  } // while client connesso 
} // if client
/*fine parte che riceve i dati*/

/*parte che invia i dati*/
 Client client_t(serverphp,80);
 if (client_t.connect()) {  
          s.print("GET /arduino/paginaphp.php?campo=qualcosa&");
...
          s.println(" HTTP/1.1");
          s.println("Host:192.138.80.81");
          s.println(); 
 client_t.stop(); 
}
/*fine parte che invia i dati*/

delay(1000);     
          
} //loop

Non sono del tutto contento perchè avrei voluto evitare ad Arduino di costruire l'html per non sovraccaricarlo di lavoro ma ho imparato un sacco di cose che mi saranno utili, pertanto al momento mi ritengo soddisfatto :smiley:

Grazie ancora di tutto a tutti voi per l'aiuto fondamentale in questo progettino!!!

PS tra qualche giorno finiti i test posterò il codice funzionante con annesso file PHP per l'invio di SMS senza GSM shield utilizzando il servizio di notifica via SMS messo a disposizione da Google Calendar.

A presto e grazie ancora,
Gianni

aspetto il resto del codice prima di dirti come fare senza html

Ho finito prima del previsto! E' tutto funzionante!
Per quanto riguarda lo sketch lo posto qui ma ho fatto un articolo sul mio sito dove c'è la spiegazione dettagliata dello sketch e dei file PHP che servono per l'utilizzo delle notifiche via SMS tramite i servizi di Google.
Riportato il link all'articolo dove c'è disponibile lo sketch e i file PHP necessari al funzionamento con annessa descrizione:
Arduino: Controllo Remoto e Notifica via SMS senza GSM shield
Qui sotto riporto lo sketch di Arduino che rimane in attesa di una stringa HTTP. Quando questa è vera attiva il "notificatore" non fa altro che invare un GET ad una pagina PHP che elabora la richiesta.

#include <String.h>
#include <SPI.h>
#include <Ethernet.h>

/* ***
 controllare un attuatore via web
 con sensori di temperatura, luce e interruttore magnetico
 ed invivio di GET per la notifica dello status via SMS con Google Calendar
 ARDUINO UNO
 ETHERNET SHIELD
 by Gianni Favilli - www.giannifavilli.it
 Readme: http://www.giannifavilli.it/blog/arduino-webcontrol-gcal-sms
 *** */

byte mac[] = { 
  0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; // mac address
byte ip[] = { 
  192, 168, xxx, xxx }; // ip arduino
byte gateway[] = { 
  192, 168, xxx, xxx }; // internet gateway
byte subnet[] = { 
  255, 255, xxx, xxx }; //subnet
byte serverphp[] = { 
  xxx, xxx, xxx, xxx }; // ip del server php a cui inviare dati

Server server(80); //server port

String leggoStringa; // string 
boolean currentLineIsBlank = true;
boolean Notifica = false; // flag status attivatore notifica sms
int NotifyValSwitch = 0;     // variabile per leggere lo stato del pin
long ContaCicliNotifica = 0;   // contatore di loop

int outPinRele = 9; // pin attuatore

/*termistore*/
float Temp; // variabile da calcolare
float inTemp = 1;   // pin analogico IN temperature sensor
/*end termistore*/

/*fotoresistore*/
int Lux; // variabile da calcolare
int inPhotoresistor = 0; // pin analogico IN fotoresistore
/*end fotoresistore*/

/* interruttore allarme a contatto magnetico*/
int ledPinSwitch = 8; // pin per il led interruttore
int inSwitch = 2;   //  pin DIGITALE per l'interruttore
int valSwitch = 0;     // variabile per leggere lo stato del pin
/* end interruttore allarme a contatto magnetico*/

int ledPinNotify = 7; // pin led Notifica attiva

void setup(){
  Ethernet.begin(mac, ip, gateway, subnet); //inizializzo eth shield
  pinMode(outPinRele, OUTPUT); // dichiaro l'output del rele
  pinMode(ledPinNotify, OUTPUT); // dichiaro l'output delled lux
  pinMode(ledPinSwitch, OUTPUT);  // dichiaro l'output del led interruttore
  pinMode(inSwitch, INPUT);    // dichiaro l'input dell'interruttore
  Serial.begin(9600);
  Serial.println("Connessione in corso...");
}

void loop(){

  /*inizio calcolo temperatura*/
  Temp = ((5 * analogRead(inTemp) * 100.0 ) / 1024) - 50;
  /*fine calcolo temperatura*/

  /*inizio lettura luce*/
  Lux = analogRead(inPhotoresistor); 
  /*fine clacolo luce*/

  /*inizio lettura switch*/
  valSwitch = digitalRead(inSwitch);  // legge il valore dell'input switch
  /*fine clacolo switch*/

  /*inizio attuatore led interruttore magnetico*/
  // accendo o spengo un led se l'interruttore viene aperto o chiuso 
  if (valSwitch == HIGH) {        
    digitalWrite(ledPinSwitch, HIGH);  // accende il LED dell'interruttore magnetico
    NotifyValSwitch = 1; // attiva il notificatore dell'interruttore magnetico
	// conta i cicli ad ogni loop per evitare l'invio di 'infiniti' sms
	// l'sms viene inviato solo quanto ContaCicliNotifica = 1 ovvero solo al primo loop
    ContaCicliNotifica = ContaCicliNotifica++; 
  } 
  else { // altrimenti
    digitalWrite(ledPinSwitch, LOW);  // spegne il LED dell'interruttore magnetico
    ContaCicliNotifica = 0;
    NotifyValSwitch = 0;
  }
  /*fine attuatore led interruttore magnetico*/

  // abilito il client-server per la lettura in ingresso della stringa http
  Client client = server.available();

  if (client) {
    boolean currentLineIsBlank = true;
    while (client.connected()) {
      if (client.available()) {
        char c = client.read();
        leggoStringa.concat(c); 
        if (c == '\n' && currentLineIsBlank) {
          if(leggoStringa.indexOf("ATT=1") > 0) { // controllo se nella stringa http in entrata finisce con ON
            // se e' ON
            digitalWrite(outPinRele, HIGH); // attiva rele'
            digitalWrite(ledPinNotify, HIGH); // attiva led 
            Notifica = true; // attivo la notifica degli sms
            Serial.println("Notifiche ON");
          }
          else{
            // se e' OFF
            digitalWrite(outPinRele, LOW); // disattiva rele'
            digitalWrite(ledPinNotify, LOW); // disattiva led
            Notifica = false; // disabilito la notifica degli sms
            Serial.println("Notifiche OFF");
          }
          // COSTRUZIONE PAGINA HTML
          client.println("HTTP/1.1 200 OK");
          client.println("Content-Type: text/html");
          client.println();
          // inizio HTML
          client.print("<html><head><title>ARDUINO Controllo Led via WEB</title><meta http-equiv='Content-Type' content='text/html; charset=iso-8859-1' ></head><body>");
          client.println("<h1>STATO NOTIFICHE VIA SMS</h1>");
          client.println("<hr />");

          // scrivo lo stato di arduino (ON - OFF)

          if (Notifica) {
            client.println("<h2 style='color:green'>NOTIFICHE ATTIVE</h2>");
          }
          else
          {
            client.println("<h2 style='color:grey'>NOTIFICHE NON ATTIVE</h2>");
          }  
          client.println("<hr /><a href='http://www.giannifavilli.it'><em>Visita GianniFavilli.it</em></a>");
		  client.println("
<a href='http://www.giannifavilli.it/blog/arduino-webcontrol-gcal-sms'><em>Leggi l'Articolo Completo</em></a>");
		  
          // termino l'html
          client.println("</body></html>");

          // svuoto la stringa per una successiva lettura
          leggoStringa="";
          // fermo il client in ingresso
          client.stop();

        } //if c == /n 
      } // if client available
    } // while client connesso 
  } // if client

  // controllo se le notifiche via sms sono attive,
  //se NotifyValSwitch è = 1 e se ContaCicliNotifica è = 1
  if(Notifica == true && NotifyValSwitch == 1 && ContaCicliNotifica == 1){
	Serial.println("invio il GET alla pagina PHP");
    // abilito il client per l'invio del GET 
    Client client_send(serverphp,80);
    if (client_send.connect()) {  
      //definisco il GET con i dati da inviare
      client_send.print("GET /pagina-che-ascolta.php?Board=ArduinoUNO&Location=CasaMIA&");
	  // invio il valore ContaCicliNotifica fondamentale per inviare gli sms
	  // il php elabora la richiesta sse Cicli=1 ovvero lavora solo il primo loop 
      client_send.print("Cicli=");
      client_send.print(ContaCicliNotifica); 
      client_send.print("&");
	  // invio gli altri valori
      client_send.print("temp=");
      client_send.print(Temp);
      client_send.print("&");
      client_send.print("lux=");
      client_send.print(Lux);
      client_send.print("&");
      client_send.print("swt=");
      client_send.print(valSwitch);
      client_send.println(" HTTP/1.1");
      client_send.println("Host:www.giannifavilli.it");
      client_send.println(); 
      client_send.stop(); // fermo il client_send  
    } // if (client_send.connect())
  } // fine ciclo di controllo attivazione notifiche
  delay(5000);         
} //loop

Grazie ancora dell'aiuto e rimango in attesa se avete modifiche da consigliarmi o riscontrate dei bug.

Ciao,
Gianni

bel progetto, e bello anche il tuo sito, complimenti

Grazie!!! :slight_smile:

Ma una piccola dritta per eliminare del tutto la costruzione dell'html da parte di Arduino me la suggerite? :slight_smile:

scusa se rispondo ora, mi ero messo la discussione da parte e poi è finita nel dimenticatoio :roll_eyes:

se non erro l'HTML ti serve solo per accendere/spegnere le notifiche giusto?
Allora in qualche modo devi comunicare con l'arduino, e se non è via HTTP (via browser), allora via TCP, ovvero con un programma apposito fatto da te o da riga di comando via telnet(esiste su tutte le piattaforme ed è installato di base).

eliminare la parte HTML dall'arduino vuol dire aumentare la complessità o lato PC o lato utente

Grazie lesto delle risposte e dei tuoi consigli.
Proverò con telnet e php e se avrò dei risultati positivi li pubblichero.

lesto:
eliminare la parte HTML dall'arduino vuol dire aumentare la complessità o lato PC o lato utente

Sono d'accordo con quello che dici però la "programmazione" serve proprio a questo, agevolare la vita all'utente finale, io oltre che agevolarla all'utente vorrei agevolarla anche ad Arduino :slight_smile: evitandogli di fare dei client.print di html.
Con PHP me la cavo discretamente ... vediamo se riesco nell'impresa, magari utilizzando anche PHP lato server.

Grazie ancora a te e a tutti quelli che mi hanno dato man forte.
Gianni

PHP lato server può aprire un socket verso arduino. Non serve più dialogare con l'HTML ma puoi usare il canale come se fosse una seriale per intenderci, con il tuo protocollo personale

lesto:
PHP lato server può aprire un socket verso arduino. Non serve più dialogare con l'HTML

E' proprio quello che intendo fare :wink:

if (client) {
  String mess;
  while (client.connected()) {
    if (client.available()) {
      char c = client.read();
      if (c!='\n'){
         mess+=c;
      }else{
        eseguiComando(mess);
      }
    }
  }
}

con questo codice, il client PHP si può connettere e inviare più comandi separati da '\n'(a capo), la gestione dei comandi. La funzione eseguiComando(String) te la devio smazzare da te :slight_smile: