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

byte mac[] = {  0x00, 0x91, 0xBE, 0xEF, 0xFE, 0xEA }; 
byte ip[] = { 192, 168, 1 , 220 };      // IP di questo arduino, INTERRATO
IPAddress server_J3(192,168,1,200);           // IP server Junior3
IPAddress server_Apt(192,168,1,221);          // IP server arduino piano terra
IPAddress server_App(192,168,1,222);          // IP server arduino primo piano


byte connesso = 0;      // mi dice se si ่ connesso al server Junior3
long cnt_conn1 = 0;      // serve a diradare i tentativi di connessione successivi
int cnt_conn2 = 0;      // conta i tentativi di connessione al server
int cnt_conn3 = 0;      // conta i tentativi di connessione al server (long term)
int cnt_delay = 0;
int cnt_delay_rele1=0;   // ritardo da attendere prima di spegnere rele' 1 - apri bascu.
int cnt_delay_rele2=0;   // ritardo da attendere prima di spegnere rele' 2 - chiudi basc.
int cnt_delay_rele3=0;   // ritardo da attendere prima di spegnere rele' 3 - cancello esterno
int cnt_hygro=0;

long cnt_energia_1=0;
long energia1=0;
long cnt_energia_2=0;
long energia2=0;
long cnt_energia_3=0;
long energia3=0;
long cnt_energia_4=0;
long energia4=0;

int cnt_keep_alive=10;  // quando connesso, ่ il timeout per stabilire se J3 non ่ pi๙ connesso
char comando[200];      // caratteri in arrivo dal server
byte lung_comando=0;    // lunghezza comando ricevuto
char richiesta[500];    // caratteri in arrivo da un client
int lung_richiesta=0;   // lunghezza richiesta ricevuto
int esito_comando;
int segnale_comando;
int valore_comando;
byte wait_ack_variazione = 0;
int cnt_led_HB = 0;
byte flashing=0;        // indica frequenza di lampeggiamento led - 0 = nessun lampeggiamento
byte flashing_level=0;
byte flashing_direction=0;
byte flashing_posta=0;
byte flashing_garage=0;
byte toggle_led_posta=0;
byte toggle_led_garage=0;
byte stato_cancello=0;
long timer_cancello1=0;
long timer_cancello2=0;


byte tempo_ore=99;
byte tempo_minuti=99;
char tempo_14[6] = "xx:xx";
char tempo_15[6] = "xx:xx";
char tempo_16[6] = "xx:xx";
char tempo_17[6] = "xx:xx";
char tempo_18[6] = "xx:xx";
char tempo_19[6] = "xx:xx";
char tempo_20[6] = "xx:xx";
char tempo_39[6] = "xx:xx";
char tempo_40[6] = "xx:xx";
char tempo_41[6] = "xx:xx";
char tempo_42[6] = "xx:xx";
char tempo_43[6] = "xx:xx";
char tempo_44[6] = "xx:xx";
char tempo_45[6] = "xx:xx";
char tempo_46[6] = "xx:xx";
char tempo_47[6] = "xx:xx";
char tempo_48[6] = "xx:xx";
char tempo_49[6] = "xx:xx";

char tempo_old14[6] = "yy:yy";
char tempo_old15[6] = "yy:yy";
char tempo_old16[6] = "yy:yy";
char tempo_old17[6] = "yy:yy";
char tempo_old18[6] = "yy:yy";
char tempo_old19[6] = "yy:yy";
char tempo_old20[6] = "yy:yy";
char tempo_old39[6] = "yy:yy";
char tempo_old40[6] = "yy:yy";
char tempo_old41[6] = "yy:yy";
char tempo_old42[6] = "yy:yy";
char tempo_old43[6] = "yy:yy";
char tempo_old44[6] = "yy:yy";
char tempo_old45[6] = "yy:yy";
char tempo_old46[6] = "yy:yy";
char tempo_old47[6] = "yy:yy";
char tempo_old48[6] = "yy:yy";
char tempo_old49[6] = "yy:yy";


// ==============================================================
// segnali digitali INPUT
// 0 = chiuso    1 = aperto
// ad ogni cambiamento di stato c'่ la notifica - preimposto a 2 cos์ allo startup aggiorna J3
//

//input
byte s14=2;   // energia 1
byte s15=2;   // energia 2
byte s16=2;   // energia 3
byte s17=2;   // energia 4

byte s18=2;   // ring campanello citofono
byte s19=2;   // spare
byte s20=2;   // apertura posta

byte s39=2;  // AUX2 centralina allarme
byte s40=2;  // AUX1 centralina allarme
byte s41=2;  // rel่ allarme

byte s42=2;  // campanello porta ingresso
byte s43=2;  // allagamento
byte s44=2;  // apertura cancelletto
byte s45=2;  // apertura cancello grande
byte s46=2;  // movimento esterno
byte s47=2;  // basculante in apertura
byte s48=2;  // movimento garage
byte s49=2;  // movimento taverna



// ==============================================================
// segnali analogici
//
int a02=4444; //  spare
float af02=500-0;
int a02cnt=0;
int a03=4444; //  hygro
float af03=500-0;
int a03cnt=2;
int a04=4444; //  temperatura scheda
float af04=500-0;
int a04cnt=3;
int a05=4444; //  crepuscolare
float af05=500-0;
int a05cnt=4;

int a06=4444; //  livello 220v
float af06=500-0;
int a06cnt=5;
int a07=4444; //  crepuscolare
float af07=500-0;
int a07cnt=6;
int a08=4444; //  NTC2
float af08=500-0;
int a08cnt=7;
int a09=4444; //  NTC3
float af09=500-0;
int a09cnt=8;

int a10=4444; // LTA 1
float af10=500-0;
int a10cnt=9;
int a11=4444; // LTA 1
float af11=500-0;
int a11cnt=10;
int a12=4444; // LTA 1
float af12=500-0;
int a12cnt=20;
int a13=4444; // LTA 2
float af13=500-0;
int a13cnt=30;
int a14=4444; // LTA 2
float af14=500-0;
int a14cnt=40;
int a15=4444; // LTA 2
float af15=500-0;
int a15cnt=50;

// ==============================================================
// comandi segnali uscita
// 0 spegne, 1 accende, oppure 1..255 imposta accensione livello PWM
//
byte o21=2;   // led HB

byte o22=2;  // LED bancone
byte o23=2;  // LED posta
byte o24=2;  // rel่ luce garage
byte o25=2;  // out spare

byte o26=2;  // o.c. luci out park
byte o27=2;  // o.c. luci out albero
byte o28=2;  // o.c. rel่ apri basculante
byte o29=2;  // o.c. rel่ chiudi basculante 
byte o30=2;  // o.c. luci LED ingresso
byte o31=2;  // o.c. apri cancello grande

byte o32=2;  // rel่ irrigazione zona 1 
byte o33=2;  // rel่ irrigazione zona 2
byte o34=2;  // rel่ irrigazione zona 3
byte o35=2;  // rel่ irrigazione zona 4
byte o36=2;  // rel่ irrigazione zona 5
byte o37=2;  // rel่ spare

byte o38=2;  // cicalino

//pwm
byte o02=0;  // LED LTA
byte o03=0;  // LED LTA
byte o05=0;  // hygro
byte o06=0;  // spare

byte o08=0;  // spare
byte o09=0;  // ventola

byte o11=0;  // PWM spare
byte o12=0;  // PWM spare

// =================================================================

// Initialize the Ethernet client library
EthernetClient client;
// Initialize the Ethernet server library
EthernetServer server(300);


void setup() {
  // start the serial library:
  Serial.begin(9600);
  Serial.println("***** start Arduino Interrato *****");
  // start the Ethernet connection:
  Ethernet.begin(mac,ip);
  server.begin();
  // give the Ethernet shield a second to initialize:
  delay(2000);
  
  // imposta tutte le porte OUT dell'Arduino
  //

  pinMode(21, OUTPUT);  analogWrite(21, 0);  o21=0;  // LED HB scheda
  pinMode(22, OUTPUT);  analogWrite(22, 0);  o22=0;  //
  pinMode(23, OUTPUT);  analogWrite(23, 0);  o23=0;  //
  pinMode(24, OUTPUT);  analogWrite(24, 0);  o24=0;  // 
  pinMode(25, OUTPUT);  analogWrite(25, 0);  o25=0;  // 
  pinMode(26, OUTPUT);  analogWrite(26, 0);  o26=0;  // 
  pinMode(27, OUTPUT);  analogWrite(27, 0);  o27=0;  // 
  pinMode(28, OUTPUT);  analogWrite(28, 0);  o28=0;  // 
  pinMode(29, OUTPUT);  analogWrite(29, 0);  o29=0;  // 
  pinMode(30, OUTPUT);  analogWrite(30, 0);  o30=0;  // 
  pinMode(31, OUTPUT);  analogWrite(31, 0);  o31=0;  // 
  pinMode(32, OUTPUT);  analogWrite(32, 0);  o32=0;  // 
  pinMode(33, OUTPUT);  analogWrite(33, 0);  o33=0;  // 
  pinMode(34, OUTPUT);  analogWrite(34, 0);  o34=0;  // 
  pinMode(35, OUTPUT);  analogWrite(35, 0);  o35=0;  // 
  pinMode(36, OUTPUT);  analogWrite(36, 0);  o36=0;  // 
  pinMode(37, OUTPUT);  analogWrite(37, 0);  o37=0;  // 
  pinMode(38, OUTPUT);  analogWrite(38, 0);  o38=0;  // cicalino
    
  pinMode(2, OUTPUT);   digitalWrite(2, LOW);   o02=0;  // LED 1 PWM
  pinMode(3, OUTPUT);   digitalWrite(3, LOW);   o03=0;  // LED 2 PWM
  pinMode(5, INPUT);    o05=0;  // segnale per lettura HYGRO - mettilo in alta impedenza se non usato
  pinMode(6, OUTPUT);   digitalWrite(6, LOW);   o06=0;  // 
  pinMode(8, OUTPUT);   digitalWrite(8, LOW);   o08=0;  // 
  pinMode(9, OUTPUT);   digitalWrite(9, LOW);   o09=0;  // 
  pinMode(11, OUTPUT);  digitalWrite(11, LOW);  o11=0;  // 
  pinMode(12, OUTPUT);  digitalWrite(12, LOW);  o12=0;  // 

  pinMode(13, OUTPUT);  digitalWrite(13, LOW);  // LED onboard

  
  // non serve impostare i PIN come INPUT, per default sono input (sia analogici che digitali)

  Serial.println("Init fatto");
}



void loop()
{
// gestione richieste su porta 300, in ogni caso anche se non sono connesso a J3
gestisci_richieste_entranti();
led_posta();
led_garage();
// rileva cambiamenti delle porte
verifica_eventi();


// led HB
cnt_led_HB++;
if (connesso)  if (cnt_led_HB % 5000 == 0) toggle_LED();
if (!connesso) if (cnt_led_HB % 500 == 0) toggle_LED();
// gestisci lo spegnimento automatico dei rele' dopo tot tempo
if (cnt_delay_rele1>0) {cnt_delay_rele1--; if (cnt_delay_rele1==0) {digitalWrite(28,0);o28=0;}}
if (cnt_delay_rele2>0) {cnt_delay_rele2--; if (cnt_delay_rele2==0) {digitalWrite(29,0);o29=0;}}
if (cnt_delay_rele3>0) {cnt_delay_rele3--; if (cnt_delay_rele3==0) {digitalWrite(31,0);o31=0;}}
if (cnt_led_HB % 10 == 0) { cnt_energia_1++; cnt_energia_2++; cnt_energia_3++; cnt_energia_4++; }
if (timer_cancello1>0) {timer_cancello1--; if (timer_cancello1==0) {stato_cancello=2; segnala_variazione(45,2);} }  // timer cancello "in apertura" - dopo 30s ่ "aperto"
if (timer_cancello2>0) {timer_cancello2--; if (timer_cancello2==0) {stato_cancello=0; segnala_variazione(45,0);} }  // timer cancello "in chiusura"


if (connesso == 0)
   if (!(cnt_conn1++ % 40000)) {   // adeguato intervallo - circa 12 secondi
     if (client.connect(server_J3, 40001))  {       // il server attende l'arduino interrato alla porta 40001
      connesso=1; 
      Serial.println("connesso a Junior3");
      if ((tempo_ore==99 && tempo_minuti==99) || (tempo_ore>7 && tempo_ore<22) )
         {digitalWrite(38,1); delay(5); digitalWrite(38,0); delay(50);   // BIBIP
         digitalWrite(38,1); delay(5); digitalWrite(38,0); }
      } 
      else Serial.print(".");
      if (cnt_conn2 % 2) {
           digitalWrite(13, LOW); }
         else {
           digitalWrite(13, HIGH); }
      if (cnt_conn2++ > 20) {  // qui significa che sto provando a collegarmi da molto tempo
         cnt_conn2=0; cnt_conn3++;
         Serial.println(".");
         Serial.print("Junior3 sono risponde... ");
         digitalWrite(38,1);   delay(5);   digitalWrite(38,0);
         // non mi collego al server -- vedremo in seguito cosa fare qua

         }
      }
   
if (connesso == 1) {
   //*******************************************************************************
   
   // verifica se ci sono comandi da Junior3 - non ho mai comandi in sequenza, sempre uno alla volta con attesa di ACK
   while (client.available() && lung_comando<199) {
      comando[lung_comando++] = client.read();
      comando[lung_comando]=0;
      }
   
   if (lung_comando==1 and comando[0]=='.') {   // carattere di keep alive da J3
      lung_comando=0;
      cnt_keep_alive=10;              // da aggiustare per il periodo di keep alive
      Serial.print(".");
      }
      
   if (lung_comando>0) {
      Serial.print("RX comando: "); 
      Serial.print(comando);
      // fai il parsing del comando ed eseguilo  -  se tutto OK rispondi "#" altrimenti "%"
      esito_comando=esegui_comando();
      if (esito_comando==0)  
         {client.print("#");
         Serial.println("  ...eseguito");
         }
       else
         {client.print("%");
         Serial.print("  ...non eseguito, errore ");
         Serial.println(esito_comando);
         Serial.print(" segnale=");
         Serial.print(segnale_comando);
         Serial.print(" valore=");
         Serial.println(valore_comando);         
         }
      lung_comando=0;
      }    
     
   if (!client.connected()) {
      Serial.println();
      Serial.println("Disconnesso ---------");
      client.stop();
      // torna nello stato "da connettersi"
      connesso = 0;
      }
      
   //*******************************************************************************   
   }
}

   
void  verifica_eventi() {       
byte tmp;
int itmp,jtmp;
// analizza tutti gli ingressi e rileva cambiamenti da trasmettere

// questi 4 ingressi (energia) sono particolarmente veloci, vediamo se devo fare qualcosa di particolare
tmp = digitalRead(14);  
if (s14 != tmp)  {s14=tmp; if (tmp==0) {energia1=cnt_energia_1; cnt_energia_1=0;  
                                        segnala_variazione_a(64,int(843000.0/energia1)); }}  // trasmetto direttamente il valore in Watt istantanei
tmp = digitalRead(15);  
if (s15 != tmp)  {s15=tmp; if (tmp==0) {energia2=cnt_energia_2; cnt_energia_2=0;  
                                        segnala_variazione_a(65,int(843000.0/energia2)); }}
tmp = digitalRead(16);  
if (s16 != tmp)  {s16=tmp; if (tmp==0) {energia3=cnt_energia_3; cnt_energia_3=0; 
                                        segnala_variazione_a(66,int(843000.0/energia3)); }}
tmp = digitalRead(17);  
if (s17 != tmp)  {s17=tmp; if (tmp==0) {energia4=cnt_energia_4; cnt_energia_4=0; 
                                        segnala_variazione_a(67,int(843000.0/energia4)); }}

tmp = digitalRead(18);  if (s18 != tmp)  {s18=tmp; segnala_variazione(18,tmp); copia(tempo_18, tempo_old18); marca_tempo(tempo_18);}
tmp = digitalRead(19);  if (s19 != tmp)  {s19=tmp; segnala_variazione(19,tmp); copia(tempo_19, tempo_old19); marca_tempo(tempo_19);}
tmp = digitalRead(20);  if (s20 != tmp)  {s20=tmp; segnala_variazione(20,tmp); copia(tempo_20, tempo_old20); marca_tempo(tempo_20);}

tmp = digitalRead(39);  if (s39 != tmp)  {s39=tmp; segnala_variazione(39,tmp); copia(tempo_39, tempo_old39); marca_tempo(tempo_39);}
tmp = digitalRead(40);  if (s40 != tmp)  {s40=tmp; segnala_variazione(40,tmp); copia(tempo_40, tempo_old40); marca_tempo(tempo_40);}
tmp = digitalRead(41);  if (s41 != tmp)  {s41=tmp; segnala_variazione(41,tmp); copia(tempo_41, tempo_old41); marca_tempo(tempo_41);}

tmp = digitalRead(42);  if (s42 != tmp)  {s42=tmp; segnala_variazione(42,tmp); copia(tempo_42, tempo_old42); marca_tempo(tempo_42);}
tmp = digitalRead(43);  if (s43 != tmp)  {s43=tmp; segnala_variazione(43,tmp); copia(tempo_43, tempo_old43); marca_tempo(tempo_43);}
tmp = digitalRead(44);  if (s44 != tmp)  {s44=tmp; segnala_variazione(44,tmp); copia(tempo_44, tempo_old44); marca_tempo(tempo_44);}
// gestione speciale di segnale apertura cancello - c'่ una macchina a stati con timer
tmp = digitalRead(45);  if (s45 != tmp)  {s45=tmp; gestione_cancello(tmp); copia(tempo_45, tempo_old45); marca_tempo(tempo_45);}
tmp = digitalRead(46);  if (s46 != tmp)  {s46=tmp; segnala_variazione(46,tmp);  if (s46) {copia(tempo_46, tempo_old46); marca_tempo(tempo_46);}}
tmp = digitalRead(47);  if (s47 != tmp)  {s47=tmp; segnala_variazione(47,tmp); copia(tempo_47, tempo_old47); marca_tempo(tempo_47);}
tmp = digitalRead(48);  if (s48 != tmp)  {s48=tmp; segnala_variazione(48,1-tmp);  if (s48) {copia(tempo_48, tempo_old48); marca_tempo(tempo_48);}}
tmp = digitalRead(49);  if (s49 != tmp)  {s49=tmp; segnala_variazione(49,1-tmp);  if (s49) {copia(tempo_49, tempo_old49); marca_tempo(tempo_49);}}


if ((cnt_delay++ % 5000) == 0) {    // controlla gli analogici ogni tanto...

// hygro - gestione speciale
cnt_hygro++;
if (cnt_hygro == 10) {pinMode(5, OUTPUT);    o05=0;digitalWrite(5,1);}
if (cnt_hygro == 15) {
  itmp = analogRead(3); digitalWrite(5,0); pinMode(5, INPUT);
  af03=0.95*af03 + 0.05*float(itmp); jtmp=int(af03); if (a03!=jtmp || a03cnt++ > 100) {segnala_variazione_a(3,jtmp); a03=jtmp; a03cnt=0;}
  }
if (cnt_hygro>30) cnt_hygro=0;

// temperatura scheda
itmp = analogRead(4);  af04=0.95*af04 + 0.05*float(itmp); jtmp=int(af04); if (a04!=jtmp || a04cnt++ > 100) {segnala_variazione_a(4,jtmp); a04=jtmp; a04cnt=0;}

// crepuscolare 1 e 2
itmp = analogRead(5);  af05=0.9*af05 + 0.1*float(itmp); jtmp=int(af05); if (a05!=jtmp || a05cnt++ > 100) {segnala_variazione_a(5,jtmp); a05=jtmp; a05cnt=0;}
itmp = analogRead(7);  af07=0.9*af07 + 0.1*float(itmp); jtmp=int(af07); if (a07!=jtmp || a07cnt++ > 100) {segnala_variazione_a(7,jtmp); a07=jtmp; a07cnt=0;}

// rete 220Volt
itmp = analogRead(6);
if (abs(a06 - itmp)>40) { a06=itmp; af06=(float)itmp; segnala_variazione_a(6,a06); }
   else  { af06=0.9*af06 + 0.1*float(itmp); jtmp=int(af06); if (a06!=jtmp || a06cnt++ > 100) {segnala_variazione_a(6,jtmp); a06=jtmp;a06cnt=0;} }

// le due NTC
itmp = analogRead(8);  af08=0.95*af08 + 0.05*float(itmp); jtmp=int(af08); if (a08!=jtmp || a08cnt++ > 100) {segnala_variazione_a(8,jtmp); a08=jtmp; a08cnt=0;}
itmp = analogRead(9);  af09=0.95*af09 + 0.05*float(itmp); jtmp=int(af09); if (a09!=jtmp || a09cnt++ > 100) {segnala_variazione_a(9,jtmp); a09=jtmp; a09cnt=0;}

// le due LTA
itmp = analogRead(10);  af10=0.9*af10 + 0.1*float(itmp); jtmp=int(af10); if (a10!=jtmp || a10cnt++ > 100) {segnala_variazione_a(10,jtmp); a10=jtmp; a10cnt=0;}
itmp = analogRead(11);  af11=0.9*af11 + 0.1*float(itmp); jtmp=int(af11); if (a11!=jtmp || a11cnt++ > 100) {segnala_variazione_a(11,jtmp); a11=jtmp; a11cnt=0;}
itmp = analogRead(12);  af12=0.9*af12 + 0.1*float(itmp); jtmp=int(af12); if (a12!=jtmp || a12cnt++ > 100) {segnala_variazione_a(12,jtmp); a12=jtmp; a12cnt=0;}
itmp = analogRead(13);  af13=0.9*af13 + 0.1*float(itmp); jtmp=int(af13); if (a13!=jtmp || a13cnt++ > 100) {segnala_variazione_a(13,jtmp); a13=jtmp; a13cnt=0;}
itmp = analogRead(14);  af14=0.9*af14 + 0.1*float(itmp); jtmp=int(af14); if (a14!=jtmp || a14cnt++ > 100) {segnala_variazione_a(14,jtmp); a14=jtmp; a14cnt=0;}
itmp = analogRead(15);  af15=0.9*af15 + 0.1*float(itmp); jtmp=int(af15); if (a15!=jtmp || a15cnt++ > 100) {segnala_variazione_a(15,jtmp); a15=jtmp; a15cnt=0;}

}


if (connesso==1 && (cnt_delay % 15000) == 0) {
     // segnale HeartBeat verso J3
     client.print("$");
     Serial.println("$");
     // controllo timeout HeartBeat da J3
     if (cnt_keep_alive > 0) cnt_keep_alive--;
        else {
          // qui significa che J3 non mi invia piu' segnale HB
          Serial.println("J3 non mi invia HB.... mi disconnetto");
          client.stop();
          connesso=0;
          cnt_keep_alive=10;
          }  
}

}

void segnala_variazione(byte segnale, byte valore) {        // invia la variazione a J3, segnale digitale 0 o 1
char s1,s2,c1,segnale_trasmesso;
segnale_trasmesso=segnale;


Serial.print(" S"); Serial.print(segnale_trasmesso);Serial.print("=");Serial.print(valore);
if (wait_ack_variazione==0) {
  s1 = segnale_trasmesso / 10 + '0';   s2 = segnale_trasmesso  % 10 + '0';   
  c1 = '0';
  if (valore==1) c1 = '1';
  if (valore==2) c1 = '2';
  if (valore==3) c1 = '3';
  client.print("@"); client.print(s1); client.print(s2); client.print("000"); client.print(c1); client.print("!"); 
  //wait_ack_variazione=1;
  } else {
  // metti la variazione in coda, aspettando che J3 dia l'ack
  //
  }  
}


void segnala_variazione_a(byte segnale, int valore) {        // invia la variazione a J3, segnala analogico
char s1,s2,c1,c2,c3,c4;
int val;

// Serial.print(" S"); Serial.print(segnale);Serial.print("=");Serial.print(valore);
if (wait_ack_variazione==0) {
  val=valore;
  s1 = segnale / 10 + '0';   s2 = segnale % 10 + '0';
  c1 = val / 1000 + '0';   val=val % 1000; c2 = val / 100 + '0';   val=val % 100;  c3 = val/10 + '0'; val=val % 10; c4 = val + '0';
  client.print("@"); client.print(s1); client.print(s2); 
  client.print(c1); client.print(c2); client.print(c3); client.print(c4);client.print("!"); 
  //wait_ack_variazione=1;
  } else {
  // metti la variazione in coda, aspettando che J3 dia l'ack
  //
  }  
}

void gestisci_richieste_entranti() {  // serve a gestire eventuali richieste esterne sulla porta 300
// al momento invita lo stato degli ingressi

EthernetClient client_300 = server.available();

if (client_300.available()) {
    Serial.println("In arrivo dati da client... ");
    lung_richiesta=0;
    // c'่ qualcosa da leggere
    while (client_300.available() && lung_richiesta<450)   
          if (client_300.connected())  richiesta[lung_richiesta++] = client_300.read();
    richiesta[lung_richiesta]=0;
    Serial.print("ricevuta richiesta: ");
    Serial.println(richiesta);
     if (client_300.connected()) {
        // se i primi 3 caratteri sono "GET" allora ่ una richiesta http da un browser e allora rispondi con una pagina html
        if (lung_richiesta >20 && richiesta[0]=='G' && richiesta[1]=='E' && richiesta[2]=='T') 
          {
          client_300.println("HTTP/1.1 200 OK");
          client_300.println("Content-Type: text/html");
          client_300.println();
          client_300.println(richiesta);
          client_300.println("</p> Risposta da ARDUINO interrato - Junior3 GP");
          client_300.println("</p> STATO connessione a controller: ");
          if (connesso==1) client_300.print("ok connesso");
          if (connesso==0) {client_300.print("KO DISCONNESSO - tentativi="); client_300.print(cnt_conn3);}

          client_300.print("</p> 14-PWRinterrato="); client_300.print(energia1);  client_300.print(" "); client_300.print(843000/energia1); client_300.print("W");
          
          client_300.print("&nbsp; &nbsp; 15-PWRpianoterra="); client_300.println(energia2);  client_300.print(" "); client_300.print(843000/energia2); client_300.print("W");
          client_300.print("&nbsp; &nbsp; 16-PWRprimopiano="); client_300.print(energia3);  client_300.print(" "); client_300.print(843000/energia3); client_300.print("W");
          client_300.print("&nbsp; &nbsp; 17-PWRservizi="); client_300.println(energia4);  client_300.print(" "); client_300.print(843000/energia4); client_300.print("W");
          
          client_300.print("</br>18-ring-citofono="); client_300.print(s18); 
          client_300.print(" t="); client_300.print(tempo_18); client_300.print(" -- "); client_300.print(tempo_old18);
          client_300.print( "&nbsp; &nbsp; 20-posta="); client_300.println(s20);
          client_300.print(" t="); client_300.print(tempo_20); client_300.print(" -- "); client_300.print(tempo_old20);
          client_300.print("</br>39-aux1allarme ="); client_300.print(s39);  
          client_300.print(" t="); client_300.print(tempo_39); client_300.print(" -- "); client_300.print(tempo_old39);
          client_300.print("&nbsp; &nbsp; 40-aux2allarme="); client_300.println(s40);
          client_300.print(" t="); client_300.print(tempo_40); client_300.print(" -- "); client_300.print(tempo_old40);
          client_300.print("&nbsp; &nbsp; 41-rele-allarme="); client_300.print(s41); 
          client_300.print(" t="); client_300.print(tempo_41); client_300.print(" -- "); client_300.print(tempo_old41);
          
          client_300.print( "</p>  42-campanello="); client_300.println(s42);
          client_300.print(" t="); client_300.print(tempo_42); client_300.print(" -- "); client_300.print(tempo_old42);
          client_300.print("&nbsp; &nbsp; 43-allagamento="); client_300.print(s43);  
          client_300.print(" t="); client_300.print(tempo_43); client_300.print(" -- "); client_300.print(tempo_old43);
          client_300.print("&nbsp; &nbsp; 44-cancelletto="); client_300.println(s43);
          client_300.print(" t="); client_300.print(tempo_44); client_300.print(" -- "); client_300.print(tempo_old44);
          client_300.print("</br> 45-cancello="); client_300.print(s45);
          client_300.print(" t="); client_300.print(tempo_45); client_300.print(" -- "); client_300.print(tempo_old45);          
          client_300.print("&nbsp; &nbsp; 47-basculante="); client_300.print(s47);
          client_300.print(" t="); client_300.print(tempo_47); client_300.print(" -- "); client_300.print(tempo_old47);
          
          client_300.print("</p>46-movimento ext="); client_300.print(s46);
          client_300.print(" t="); client_300.print(tempo_46); client_300.print(" -- "); client_300.print(tempo_old46);
          client_300.print("&nbsp; &nbsp; 48-movimento garage="); client_300.print(1-s48);
          client_300.print(" t="); client_300.print(tempo_48); client_300.print(" -- "); client_300.print(tempo_old48);
          client_300.print("&nbsp; &nbsp; 49-movimento taverna="); client_300.print(1-s49);
          client_300.print(" t="); client_300.print(tempo_49); client_300.print(" -- "); client_300.print(tempo_old49);
          
          client_300.print("</p> analogico03 Hygro="); client_300.print(a03);
          client_300.print("&nbsp; &nbsp;  analogico04 T="); client_300.print(a04);
          client_300.print("&nbsp; &nbsp;  analogico06 220v="); client_300.print(a06);
          client_300.print("</br> analogico05 Crepuscolare1="); client_300.print(a05);
          client_300.print("&nbsp; &nbsp; analogico07 Crepuscolare2="); client_300.print(a07);
          
          client_300.print("</p> analogico08 NTC="); client_300.print(a08);
          client_300.print("&nbsp; &nbsp; analogico09 NTC="); client_300.print(a09);
          client_300.print("</br>analogico a10="); client_300.print(a10);
          client_300.print(" &nbsp; &nbsp;  analogico a11="); client_300.print(a11);
          client_300.print(" &nbsp; &nbsp;  analogico a12="); client_300.print(a12);
          client_300.print("</br>analogico a13="); client_300.print(a13);
          client_300.print(" &nbsp; &nbsp;  analogico a14="); client_300.print(a14);
          client_300.print(" &nbsp; &nbsp;  analogico a15="); client_300.print(a15);

          client_300.print("</p>21-led HB="); client_300.print(o21); 
          client_300.print(" &nbsp; &nbsp; 22- luce bancone="); client_300.println(o22);
          client_300.print(" &nbsp; &nbsp; 23- luce LED posta="); client_300.println(o23);
          client_300.print("</br>24-rele luce garage="); client_300.println(o24);
          client_300.print(" &nbsp; &nbsp; 26-luci park="); client_300.print(o26);
          client_300.print(" &nbsp; &nbsp; 27-luci albero="); client_300.println(o27);          
          client_300.print("</p>28-rele-apri-basculante="); client_300.println(o28);          
          client_300.print(" &nbsp; &nbsp; 29-rele-chiudi-basculante="); client_300.println(o29);          
          client_300.print("</br>30-LEDext-ingresso="); client_300.println(o30);          
          client_300.print(" &nbsp; &nbsp; 31-apri-cancellone="); client_300.println(o31);          
          client_300.print("</p>33..37-zone irrigazione 1..5 = "); 
          client_300.print(o33);client_300.print(" ");
          client_300.print(o34);client_300.print(" ");
          client_300.print(o35);client_300.print(" ");
          client_300.print(o36);client_300.print(" ");
          client_300.print(o37);
          client_300.print("</p>37-rele xx="); client_300.println(o37);          
          client_300.print(" &nbsp; &nbsp; cicalino o38="); client_300.println(o38);     
          
          client_300.print("</br>02-led="); client_300.println(o02);          
          client_300.print(" &nbsp; &nbsp; 03-led="); client_300.println(o03);          
          client_300.print(" &nbsp; &nbsp; 05-hygro on="); client_300.println(o05);          
          client_300.print(" &nbsp; &nbsp; 09-ventola="); client_300.println(o06);       
   

          client_300.println("</p> -- OK"); 
          }
        }  
    
    client_300.stop();
    }
}

int esegui_comando() {        // comando contenuto nella stringa "comando", e lunghezza comando "lung_comando"
                              // formato:   #xxyyy?   xx=numero segnale  yyy=valore da impostare
                              //                      per i digitali yyy=000 oppure 001
                              //                      per i digitali PWM  yyy=000..255
                              //
if (comando[0]=='#' && lung_comando==7 && comando[6]=='?') {
    segnale_comando=(comando[1]-'0')*10 + (comando[2]-'0');
    valore_comando=(comando[3]-'0')*100 + (comando[4]-'0')*10 + (comando[5]-'0');
    if (valore_comando<0 || valore_comando>255) return 3;    // malformed value
    if (segnale_comando>21 && segnale_comando<39 && valore_comando>1) return 3;
    
    switch (segnale_comando) {
      case 2:
        analogWrite(2,valore_comando);
        o02=valore_comando;
        return 0;
        break;  
      case 3:
        analogWrite(3,valore_comando);
        o03=valore_comando;
        return 0;
        break;  
      case 5:
        analogWrite(5,valore_comando);
        o05=valore_comando;
        return 0;
        break;  
      case 6:
        analogWrite(6,valore_comando);
        o06=valore_comando;
        return 0;
        break;  
      case 9:
        analogWrite(9,valore_comando);
        o09=valore_comando;
        return 0;
        break;  
      case 11:
        analogWrite(11,valore_comando);
        o11=valore_comando;
        return 0;
        break;  
      case 12:
        analogWrite(12,valore_comando);
        o12=valore_comando;
        return 0;
        break;  

      case 22:
        digitalWrite(22,valore_comando);
        o22=valore_comando;
        return 0;
        break;  
      case 23:
        digitalWrite(23,valore_comando);
        o23=valore_comando;
        return 0;
        break;  
      case 24:
        digitalWrite(24,valore_comando);
        o24=valore_comando;
        return 0;
        break;          
      case 25:
        digitalWrite(25,valore_comando);
        o25=valore_comando;
        return 0;
        break;  
      case 26:
        digitalWrite(26,valore_comando);
        o26=valore_comando;
        return 0;
        break;  
      case 27:
        digitalWrite(27,valore_comando);
        o27=valore_comando;
        return 0;
        break;  
      case 28:
        digitalWrite(28,valore_comando);
        o22=valore_comando;
        cnt_delay_rele1=1000;
        return 0;
        break;  
      case 29:
        digitalWrite(29,valore_comando);
        o29=valore_comando;
        cnt_delay_rele2=1000;
        return 0;
        break;  
      case 30:
        digitalWrite(30,valore_comando);
        o30=valore_comando;
        return 0;
        break;  
      case 31:
        digitalWrite(31,valore_comando);
        o31=valore_comando;
        cnt_delay_rele3=8000;    // bisogna tenere chiuso il rel่ almeno 2 secondi
        return 0;
        break;  
      case 32:
        digitalWrite(32,valore_comando);
        o32=valore_comando;
        return 0;
        break;  
      case 33:
        digitalWrite(33,valore_comando);
        o33=valore_comando;
        return 0;
        break;  
      case 34:
        digitalWrite(34,valore_comando);
        o34=valore_comando;
        return 0;
        break;  
      case 35:
        digitalWrite(35,valore_comando);
        o35=valore_comando;
        return 0;
        break;  
      case 36:
        digitalWrite(36,valore_comando);
        o36=valore_comando;
        return 0;
        break;  
      case 37:
        digitalWrite(37,valore_comando);
        o37=valore_comando;
        return 0;
        break;  
      case 38:
        digitalWrite(38,valore_comando);
        o38=valore_comando;
        return 0;
        break;  

      case 80:
        if (valore_comando<24) {tempo_ore=valore_comando;  return 0;}
               else return 2;
        break;
      case 81:
        if (valore_comando<60) {tempo_minuti=valore_comando;  return 0;}
               else return 2;
        break;
      case 82:
        // aggiorna J3 dello stato di tutte le variabili interne a questo arduino
        
        return 0;
        break;
      case 90:    // flash led posta
        flashing_posta = valore_comando;
        if (valore_comando==0) digitalWrite(23,0);
        break;
        
      case 91:    // flash led posta
        flashing_garage = valore_comando;
        if (valore_comando==0) digitalWrite(22,0);
        break;

      default:
        return 2;  // malformed signal
        }
    }  
  else return 1;  // malformed command
}

void toggle_LED() {
if (o21) { o21=0; digitalWrite(21,0);}
  else   { o21=1; digitalWrite(21,1);}
}

void marca_tempo(char st[])
{
char t1, t2, t3, t4;
t1 = tempo_ore/10;
t2 = tempo_ore - t1*10;
t3 = tempo_minuti/10;
t4 = tempo_minuti - t3*10;
st[0]= t1+48;
st[1]= t2+48;
st[2]= ':';
st[3]= t3+48;
st[4]= t4+48;
st[5]= 0;
}

void copia(char st1[],char st2[])
{
int i;
for (i=0; i<6; i++) st2[i]=st1[i];
}

void led_posta() {
if (flashing_posta)
  if ((cnt_delay % (flashing_posta*10)) == 0) {
   if (toggle_led_posta) { toggle_led_posta=0; digitalWrite(23,0); }
     else { toggle_led_posta=1; digitalWrite(23,1); }
  }
}

void led_garage() {
if (flashing_garage)
  if ((cnt_delay % (flashing_garage*10)) == 0) {
   if (toggle_led_garage) { toggle_led_garage=0; digitalWrite(22,0); }
     else { toggle_led_garage=1; digitalWrite(22,1); }
  }
}

void gestione_cancello(byte valore)
{
    switch (stato_cancello) {
      case 0:  // chiuso
        if (valore) {stato_cancello=1; timer_cancello1=4000*30; segnala_variazione(45,1); } // timeout "in apertura" di 30 secondi
        break;

      case 1:  // in apertura
        if (valore==0) {stato_cancello=2; segnala_variazione(45,2); } // cancello aperto
      break;

      case 2:  // aperto
        if (valore) {stato_cancello=3; timer_cancello2=4000*5; segnala_variazione(45,3); } // timeout "in chiusura" di 5 secondi      
      break;

      case 3:  // in chiusura
        timer_cancello2=4000*5;  // ad ogni "click" reimposta il timeout "in chiusura" ai 5 secondi      
      break;
    }
}