PitAlarm

PitAlarm, mini sistema di allarme collegato al WIFI di casa che carica gli allarmi su WEB e invia la mail di allarme.

 

Il funzionamento di PitAlarm è molto semplice. Qando viene rilevato il movimento viene inviata una mail di allarme. Sono state introdotte delle variabili temporali di controllo che fanno in modo di inviare le mail successive al primo allarme dopo un determinato lasso di tempo. Evitando in questo modo l'invio di mail successive ravvicinate.

La parte interessante è quella relativa all'invio della mail. Il codice utilizzato è stato elaborato partendo dalle istruzioni Send Mail - con server senza autenticazione SSL. All'interno del codice implementato sono riportati alcuni commenti presi dal sito stesso.

Gli allarmi vengono inoltre caricati in un file giornaliero sul WEB dove sono riassunti tutti giorno per giorno. Si veda a questo scopo quanto già implementato in PitClima (PCW)

Viene effettuata la lettura da WEB di data e ora NTP (Network Time Protocol - il codice - UdpNtpClient - fa parte degli esempi di base della libreria Ethernet).

Partendo dall'esperienza del PitClima il codice attraverso la compilazione condizionale consente l'utilizzo di della scheda Arduino con ethernet shield, di ESP01 e ESP12M1.

ozio_gallery_jgallery

Prossimi sviluppi:

Sono previsti alcuni ulterioni sviluppi che traggono spunto da precedenti esperienze in particolare si pensa all'integrazione con il lettore di carte magnetiche/dongle (RFID-RC522) per le operazioni di attivazione/disattivazione delle rilevazioni dell'allarme.

PitAlarmEsp01:

Cosa serve:

  • ESp8266 - ESP-12d1 mini
  • o ESp8266 - ESP-01 (qualche problema con il sensore PIR che andrebbe alimentato a 5V non 3.3V)
  • o Arduino con Ethernet Shield
  • HCSR501 Sensore presenza
  • cavetti

PitAlarm nella versione Esp01 propone l'utilizzo della scheda realizzata PitClimaEsp01 che come visto ha il limite di non essere in grado di supportare la soda DHT22.

E' stata semplicemente tolta la resistenza da 4.7 K e fatto un ponte tra gnd e il pin non usato dal DHT22.

In questo modo è possibile, montare direttamente sulla scheda al posto del sensore di temperatura un sensore di presenza (sensore di PIR) HCSR501.

Codice sorgente:


/* 
ZappocoS      - PitAlarm18_06_13   04/06/2018 -- ottimizzazione dati sul web e bug
ZappocoS      - PitAlarm18_06_12   03/06/2018 -- caricamento dati sul web
ZappocoS      - PitAlarm18_05_11   27/05/2018 -- integrazione lettura data e ora NTP
ZappocoS      - PitAlarm18_05_10   26/05/2018 -- integrazione codice per utilizzo con ESP8266 - ESP01
ZappocoS      - PitAlarm18_05_09   23/05/2018 -- aggiunta indicazione della stazione di rilevazione
ZappocoS      - PitAlarm18_05_08   23/05/2018 -- integrazione codice per utilizzo con ESP8266 - ESP12m
ZappocoS      - PitAlarm18_05_07   09/05/2018 -- integrazione sensore magnetico - porta
ZappocoS      - PitAlarm18_05_06   08/05/2018 -- integrazione sensoreHC-SR501
ZappocoS      - PitAlarm18_05_05   06/05/2018 -- aggiunta di reset
ZappocoS      - PitAlarm18_05_04   06/05/2018 -- aggiunta di inizializzazione
ZappocoS      - PitAlarm18_05_01   06/05/2018 -- inizio programma - assemblaggio - mail con controllo sensori
  PitAlarm  --> Stazione di allarme del PIT
  www.zappoco.altervista.org
//
// codici di riferimento Send Mail - con server senza autenticazione SSL
// istruzioni e codice da https://playground.arduino.cc/Italiano/Mail
//
*/
#define PitProgramVersion "PitAlarm V18_06_13 - by Zappoco"
//#define ESPertino
//#define ESP12
#define ESP12m
//#define ESP01
//#define ArduinoUNO
//#define ArduinoM0Pro
//#define ArduinoMega
#define PitStation "AL01"
//----------------------------------------------------------------------------------------
//  Settaggio flag per stampa su seriale di dati per debug e led come sistema di controllo
//----------------------------------------------------------------------------------------
#define OnSerial       // stampa sulla seriale
//#define OnDebug        // accorcia i tempi
#define OnSendMail     // spedisce la mail
#define OnWebLogger     // spedisce la mail
#define OnSensorPir    // utilizza il Sensore PIR
//#define OnReedSwitch   // utilizza il Contatto reed
//#define OnLed          // se non viene utilizzato il Contatto reed utilizza il led
//#define OnPiuDebug     // stampa maggiori dettagli sulla seriale
//----------------------------------------------------------------------------------------
// Esegue il Reset ogni 10 cicli
//----------------------------------------------------------------------------------------
#define OnReset              //Attiva il reset
#ifdef OnDebug     
  #define intTime  120000    // setta a 2 minuti (120000 millisecondi) l'intervallo tra gli allarmi (timedelay)
  #define intReset 5         // setta a 5 le volte per il ritardo reset
#else
  #define intTime 300000     // setta a 5 minuti (300000 millisecondi) l'intervallo tra gli allarmi (timedelay)
  //#define intReset 24        // setta a 24 le volte per il ritardo reset  --> 2 ore
  #define intReset 72        // setta a 72 le volte per il ritardo reset  --> 6 ore 
#endif
#if defined(PitStation)
  String PitSt  = PitStation;
#else
  String PitSt  = "";
#endif
String PitAlarmDir = "/Z_PitAlarm/";
#if defined(ARDUINO_ARCH_SAMD)  // for M0 Pro, output on USB Serial console, remove line below if using programming port to program the Zero!
   #define Serial SerialUSB
#endif
//----------------------------------------------------------------------------------------
// ---------------------------------------------------
// impostazione della variabile che serve per individuare
// la scheda in uso in modo da selezionare automaticamente
// le libreria di collegamento al WEB
// ---------------------------------------------------
#if defined(ESPertino)
  #define ESPWiFi
#elif defined(ESP12) || defined(ESP12m)  || defined(ESP01)
  #define ESP8266  
#elif defined(ArduinoUNO) || defined(ArduinoM0Pro) || defined(ArduinoMega)
  #define EthernetShield
#endif
//----------------------------------------------------------------------------------------
// Se è presente internet fa la sincronizzazione NTP
//----------------------------------------------------------------------------------------
#if defined(EthernetShield) || defined(ESP8266) || defined(ESPWiFi)  // --> espertino verificare
  #define TimeNTP
#endif
#if defined(ESPWiFi) || defined(EthernetShield) || defined(ESP8266)
  #define MySsid "MioSsid"
  #define MyPassword "MiaPWD"
  #define MyHost "www.miosito.com"
#endif
// ---------------------------------------------------
// Funzione di reset
// Dichiarazione di funzione che punta all'indirizzo zero
// ---------------------------------------------------
#ifdef ESP8266  
#else
  #ifdef OnReset
    void(* Riavvia)(void) = 0;
  #endif
#endif
// ---------------------------------------------------
#include 
boolean FlagSended = false;   // Flag di mail spedita
boolean FlagAllarme = false;  //Flag di allarme rilevato
#ifdef EthernetShield
  #include  
  // ---------------------------------------------------
  // Local network configuration:
  // Enter a MAC address for your controller below.
  // Newer Ethernet shields have a MAC address printed on a sticker on the shield
  byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };   // mac address
  // if you don't want to use DNS (and reduce your sketch size)
  // use the numeric IP instead of the name for the server:
  char host[] = MyHost;
  // Set the static IP address to use if the DHCP fails to assign
  IPAddress ip(192,168,188,51);
  EthernetClient client;  
#endif   
#ifdef ESPWiFi
  //----------------------------------------------------------------------------------------
  // librerie WiFi - ESPWiFi
  //----------------------------------------------------------------------------------------
  #include 
  #include 
  WiFiMulti WiFiMulti;
  WiFiClient client;
#endif   
#ifdef ESP8266
    //----------------------------------------------------------------------------------------
    // librerie WiFi - ESP12 o ESP01
    //----------------------------------------------------------------------------------------
    #include 
    WiFiServer server(80);
    WiFiClient client = server.available();
#endif   
#if defined(ESPWiFi) || defined(ESP8266)
    const char* ssid     = MySsid;
    const char* password = MyPassword;
    const char* host = MyHost;
#endif   
#if defined(TimeNTP)
    #include 
    #ifdef EthernetShield
      #include 
    #endif
    #if defined(ESPWiFi) || defined(ESP8266)
      #include 
    #endif
    //----------------------------------------------------------------------------------------
    // librerie RTC per lettura da 
    //----------------------------------------------------------------------------------------
    // NTP Servers:
    // IPAddress timeServer(193, 204, 114, 232); // ntp1.inrim.it -->  www.inrim.it (istituto nazionale di ricerca e meteorologia)
    // IPAddress timeServer(193, 204, 114, 233); // ntp2.inrim.it -->  www.inrim.it (istituto nazionale di ricerca e meteorologia)
    IPAddress timeServer(193, 204, 114, 105); // time.inrim.it -->  www.inrim.it (istituto nazionale di ricerca e meteorologia)
    const int timeZone = 2;     // Central European Time
    //const int timeZone = -5;  // Eastern Standard Time (USA)
    //const int timeZone = -4;  // Eastern Daylight Time (USA)
    //const int timeZone = -8;  // Pacific Standard Time (USA)
    //const int timeZone = -7;  // Pacific Daylight Time (USA)
    unsigned int localPort = 8888;  // local port to listen for UDP packets
    #ifdef EthernetShield
      EthernetUDP Udp;
      time_t prevDisplay = 0; // when the digital clock was displayed
    #endif
    #if defined(ESPWiFi) || defined(ESP8266)
      time_t prevDisplay = 0; // when the digital clock was displayed
      WiFiUDP Udp;
      time_t getNtpTime();
    #endif
#endif
// ---------------------------------------------------
// bisogna inserire il proprio username e password.
// Questa è la parte più complessa, percè ormai quasi tutti i provider richiedono
// l'autenticazione dell'utente per poter inviare e-mail , e per fare ciò è necessario
// convertire le proprie credenziali di accesso (username e password) in formato "BASE64";
// al momento non è disponibile una libreria Arduino che lo faccia, quindi è necessario
// appoggiarsi "una tantum" a un server esterno per convertire le proprie credenziali,
//  per esempio http://www.motobit.com/util/base64-decoder-encoder.asp e http://webnet77.com/cgi-bin/helpers/base-64.pl
// Login data:
String UserName64 = "xyzxyz";
String Password64 = "abcabc";
// bisogna scoprire l'indirizzo IP del proprio server di posta;
// il nome del server si trova nella configurazione del vostro client di posta, sotto "server in uscita";
// per scoprirne l'IP, basta inserirlo in questo sito: http://www.visualroute.it/strumenti/dnslookup.asp
byte serverOO[] = { 82, 57, 200, 132 };  // originariamente server ma variabile usata da ESP8266
// SMTP server ALICE
String ServerName = "out.alice.it";
// Mail data:
// indirizzo di chi spedisce
String Sender = "[email protected]";
// indirizzo di chi riceve
String Recipient = "[email protected]";    
// Oggetto
String  Subject = PitSt + " " + PitProgramVersion;
// Testo del messaggio \n per andare a capo
String Body = PitSt + " inizializzato correttamente";
// Testo da scrivere sul WEB
String BodyWeb = PitSt + "_inizializzato_correttamente";
//----------------------------------------------------------------------------------------
// Variabili temporali
//----------------------------------------------------------------------------------------
unsigned long TimeDelay = intTime;
unsigned long TimeReset = intReset * intTime;
unsigned long TimeStart = 0;             // tempo di partenza 
unsigned long TimeUltima = 0;            // tempo ultima lettura
unsigned long TimeAdesso = 0;            // tempo della lettura
long TimeDelta  = 0;                     // differenza
unsigned long tempo;
unsigned long Counter = 0;               // contatore delle letture
//
// variabili per salvataggio file logger giornaliero
//
String FileNameLogger ;                  // nome del file datalogger del giorno prima
String FileNameDummy ;                  // nome del file datalogger del giorno prima
String ServerResponse="";
// ---------------------------------------------------
// Variabili controllo allarme
// ---------------------------------------------------
#if defined(ESPertino)
  int pinDHT =  2;  // Pin di collegamento 2 per ESPertino
#elif defined(ESP12)
  // Pin di collegamento per ESP12
  #ifdef OnSensorPir
    int pirPin = 2;
    int pirVal;
  #endif
  // int alarmLed = 13 ;         // define LED Interface
  int reedPin = 5;           // define the key switch sensor interface attenzioene 
  int reedVal;               // define numeric variables val
#elif defined(ESP12m)
  // Pin di collegamento per ESP12 mini
  #ifdef OnSensorPir
    int pirPin = 2;
    int pirVal;
  #endif
  // int alarmLed = 13 ;         // define LED Interface
  int reedPin = 5;           // define the key switch sensor interface attenzioene 
  int reedVal;               // define numeric variables val
#elif defined(ESP01)
  // Pin di collegamento per ESP01
  #ifdef OnSensorPir
    int pirPin = 2;
    int pirVal;
  #endif
  // int alarmLed = 13 ;         // define LED Interface
  int reedPin = 0;           // define the key switch sensor interface attenzioene 
  int reedVal;               // define numeric variables val
#else
  // Pin di collegamento per Arduino
  #ifdef OnSensorPir
    int pirPin = 8;
    int pirVal;
  #endif
  //int alarmLed = 13 ;         // define LED Interface
  int reedPin = 2;           // define the key switch sensor interface attenzioene 
  int reedVal;               // define numeric variables val
#endif
void setup()
{
  #ifdef OnSerial
    Serial.begin( 9600 );
  #endif
  #ifdef OnSerial     
    // Serial.println(Arduino);
    Serial.println("");
    Serial.println("");
    Serial.println(PitProgramVersion);
    Serial.println("---------------------------");    
    #ifdef OnPiuDebug
      Serial.print  (" OnSensorPir        is ");
      #ifdef OnSensorPir
        Serial.println("on");
      #else
        Serial.println("off");
      #endif
      Serial.print  (" OnReedSwitch       is ");
      #ifdef OnReedSwitch
        Serial.println("on");
      #else
        Serial.println("off");
      #endif
      Serial.print  (" OnDebug            is ");
      #ifdef OnDebug
        Serial.println("on");
      #else
        Serial.println("off");
      #endif
      #ifdef TimeNTP
        Serial.println(" TimeNTP            is on");
      #endif
      Serial.println("---------------------------");
    #endif
  #endif 
  #if defined(EthernetShield) || defined(ESP8266) || defined(ESPWiFi)
    #ifdef OnSerial     
      Serial.print("Programma avviato, attesa del router ...");
      delay(1000);
      Serial.print(" inizializzazione modulo di rete ...");
    #endif
    #if defined(ESPWiFi)
      //
      // Inizializzazione WiFi per l'utilizzo con ESPWiFi
      //
      WiFiMulti.addAP(ssid, password);
      #ifdef OnSerial     
        Serial.print(" wait for WiFi ... ");
      #endif
      while(WiFiMulti.run() != WL_CONNECTED) {
        #ifdef OnSerial     
          Serial.print(".");
        #endif
        delay(500);
      }
      //-----Gestione iniziale WiFi
      // WiFi.begin(ssid, password);
      #ifdef OnSerial
        Serial.println();
        Serial.println(" aspetto 10 secondi per Wifi ...");
        Serial.print(" Wifi collegato, l'IP di ESPWiFi e' ");
        Serial.println(WiFi.localIP());
        Serial.println(); 
      #endif
    #elif defined(EthernetShield)
      // Ethernet.begin(mac, ip);
      // start the Ethernet connection:
      if (Ethernet.begin(mac) == 0) {
        #ifdef OnSerial     
          Serial.println(" failed to configure Ethernet using DHCP");
        #endif
        // no point in carrying on, so do nothing forevermore:
        // try to congifure using IP address instead of DHCP:
        Ethernet.begin(mac, ip);
      }
      // give the Ethernet shield a second to initialize:
      delay(1000);
    #elif defined(ESP8266)
      //
      // Inizializzazione Scheda di rete per l'utilizzo con ESP8266
      //
      // Connect to WiFi network
      WiFi.mode(WIFI_STA);
      #ifdef OnSerial     
        Serial.print(" connecting to ");
        Serial.print(ssid);
      #endif
      WiFi.begin(ssid, password);
      while (WiFi.status() != WL_CONNECTED) {
          delay(125);  
          #ifdef OnSerial     
            Serial.print(".");  
          #endif
      }
      #ifdef OnSerial     
        Serial.println("");
        Serial.print(" WiFi connected ... ");
      #endif
      // Start the server
      server.begin();
      #ifdef OnSerial     
        Serial.print(" Server started ... ");
        // Print the IP address          
        Serial.println(WiFi.localIP());    
      #endif
    #endif
    delay(2000);
    #ifdef OnSerial     
      Serial.println(" inizializzazione completata");
    #endif 
  #endif 
  #ifdef TimeNTP
      // NTP Time
      #ifdef EthernetShield
        Udp.begin(localPort);
        #ifdef OnSerial     
          Serial.print(" waiting for sync ... ");
          setSyncProvider(getNtpTime);
          // setSyncInterval(300);
        #endif
      #endif
      #if defined(ESPWiFi) || defined(ESP8266)
        Udp.begin(localPort);
        #ifdef OnSerial     
          #ifdef ESP8266
            Serial.print(" local port: ");
            Serial.print(Udp.localPort());
          #endif
          Serial.print(" waiting for sync ... ");
        #endif
        setSyncProvider(getNtpTime);
        setSyncInterval(300);
      #endif
      time_t prevDisplay = 0; // when the digital clock was displayed
  #endif
  #ifdef OnSensorPir
    pinMode (pirPin, INPUT);  
  #endif
  #ifdef OnReedSwitch
	  pinMode (reedPin, INPUT);
  #else
	  pinMode (reedPin, OUTPUT);
    digitalWrite (reedPin, LOW);
  #endif
  //pinMode (alarmLed, OUTPUT); // define LED as output interface
  //Inizializzazione
  PrintAlarmData ();
  /*
  //Mail di inizializzazione
  #ifdef OnSendMail
    if (client.connect(serverOO, 25)) {    //originariamente server
      #ifdef OnSerial     
        Serial.print("Mail di inizializzazione");
        Serial.println(" - invio della mail - ");
      #endif 
      Body = GetDataOra() + Body;
      PitMailSend();
      client.stop();
    }
  #endif 
  */
  TimeStart  = millis();
  TimeAdesso = TimeStart;
  TimeUltima = TimeStart;
 }
void loop()
{
  #ifdef OnSensorPir
    pirVal = digitalRead(pirPin);
  #endif
  #ifdef OnReedSwitch
    reedVal = digitalRead (reedPin);
  #else
    reedVal = LOW;
  #endif
  #ifdef OnSerial     
    //Serial.print("reedVal ");
    //Serial.println(reedVal);
  #endif 
  if (reedVal == HIGH) {
    //digitalWrite (alarmLed, HIGH);
    #ifdef OnSerial     
      //Serial.println("+");
    #endif 
    Body = PitSt + " Allarme Reed Switch Closed.";
    BodyWeb = PitSt + "_Allarme_Reed_Switch_Closed";
    FlagAllarme = true;
  }
  #ifdef OnSensorPir
    else if (pirVal == HIGH) {
      //digitalWrite (alarmLed, HIGH);
      Body = PitSt + "_Allarme Sensore PIR.";
      BodyWeb = PitSt + "_Allarme_Sensore_PIR";
      FlagAllarme = true;
  	  #ifdef OnLed
    		digitalWrite (reedPin, HIGH);
    		delay(400);
    		digitalWrite (reedPin, LOW);
  	  #endif
    }  
  #endif
  else {
    //digitalWrite (alarmLed, LOW);
    #ifdef OnSerial     
      //Serial.print("-");
    #endif 
    //delay(200);
    //Attiva il flag per la spedizione
    FlagAllarme = false;
  }
  if (FlagAllarme )
  {
    PrintAlarmData ();
  }
  #ifdef OnReset
    TimeAdesso = millis();
    TimeDelta = TimeAdesso - TimeStart - TimeReset;
    if (TimeDelta >= 0) {
      #ifdef ESP8266  
        ESP.reset();
      #else
        Riavvia();
      #endif
      #ifdef OnSerial     
        Serial.println("Reset del sistema");
      #endif 
    }
  #endif
}
//--------------------------------------------------------------------------------------------------------------
// Questa funzione stampa i dati
// 
// -->  seriale
// -->  WEB
// -->  mail
//--------------------------------------------------------------------------------------------------------------
void PrintAlarmData () {
  // 
  TimeAdesso = millis();
  TimeDelta = TimeAdesso - TimeUltima - TimeDelay;
  if (TimeDelta >= 0) {  
    FlagSended = false;  
  }
  //BodyWeb = Body;
  #ifdef TimeNTP
    Body = GetDataOra() + Body;
  #endif
  #ifdef OnSerial     
    Serial.print ("FlagSended: ");
    Serial.print (FlagSended);
    Serial.print (" - ");
    Serial.print(Body);
    Serial.print (" - ");
    Serial.println(BodyWeb);
  #endif 
  //----------------------------------------------------------------------------------------
  // Spedisce mail
  //----------------------------------------------------------------------------------------
  #ifdef OnSendMail
    #ifdef ESPWiFi 
      //WiFiClient client;
    #endif
    #ifdef ESP8266
      //WiFiClient client = server.available();
    #endif
    if (client.connect(serverOO, 25)) {
      #ifdef OnSerial     
         Serial.print("Rete connessa");
      #endif 
      if (!FlagSended ){
        // invia la mail solo la prima volta
        #ifdef OnSerial     
          Serial.println(" - invio della mail - ");
        #endif 
        PitMailSend();
        FlagSended = true;  
        TimeUltima = millis();
      }
      else{
        client.stop();
        #ifdef OnSerial     
          Serial.print(" - non invio la mail - ");
        #endif 
      }
    } else {
      #ifdef OnSerial     
        Serial.println("Connessione fallita.");
      #endif 
    }
    //leggi i dati e si disconnettie  
    if (client.available()) {
      char c = client.read();
      #ifdef OnSerial     
        Serial.print(c);
      #endif 
    }
    if (!client.connected()) {
      #ifdef OnSerial     
        Serial.println("disconnessione.");
      #endif 
      client.stop();
      #ifdef OnSerial     
        Serial.println("completato ciclo di scrittura lettura");
      #endif 
    }
  #endif
  // fine Send Mail
  //----------------------------------------------------------------------------------------
  // Carica dati internet
  //----------------------------------------------------------------------------------------
  #ifdef OnWebLogger
    #ifdef TimeNTP
      // NTP Time
      //prevDisplay = now();
      #if defined(ESPWiFi) || defined(EthernetShield) || defined(ESP8266)
        FileNameLogger = String(year());
        if(month() < 10)
          FileNameLogger = FileNameLogger +'0';
        FileNameLogger = FileNameLogger + String(month());          
        if(day() < 10)
          FileNameLogger = FileNameLogger +'0';
        FileNameLogger = FileNameLogger + String(day());
        FileNameLogger = "dati/" + PitSt + "_" + FileNameLogger + ".txt";
      #endif
    #else
        FileNameLogger = "dati/" + PitSt + "_" + "00000000" + ".txt";      
    #endif
    #ifdef OnPiuDebug 
      Serial.print("FileNameLogger = ");
      Serial.print(FileNameLogger);
      Serial.println("");
    #endif
    #if defined(ESPWiFi) || defined(EthernetShield) || defined(ESP8266)
      String url;
      #ifdef ESPWiFi 
         WiFiClient client;
      #endif
      #ifdef ESP8266
        WiFiClient client = server.available();
      #endif
      #ifdef OnPiuDebug 
        Serial.println("Scrive dati su WEB");
      #endif
      FileNameDummy = "dati/" + PitSt + "_ZAP_logs" + ".txt";
      #ifdef OnPiuDebug 
        Serial.print("FileNameDummy = ");
        Serial.print(FileNameDummy);
        Serial.println(" ; ");
        Serial.print("Host = ");
        Serial.print(host);
        Serial.println(" ; ");
      #endif
      // ----------------------------------------------------------------
      // SCRIVE L'ALLARME NEL LOG - file DAYLOG
      // ----------------------------------------------------------------
      if (client.connect(host, 80)) {
          url = PitAlarmDir + "PHP_write_logs.php?P1=" + FileNameLogger  + "&dato=" + BodyWeb; //
          "CIAO"; //+ Body; 
          client.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
          client.stop();
          #ifdef OnPiuDebug 
            Serial.println("Writing logs File");
            Serial.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
          #endif
      }
      else
      {
          #ifdef OnSerial
            Serial.println(" error not writing on Host 1");
          #endif
      }
      // ----------------------------------------------------------------
      // COPY ALLARME - file logs
      // ----------------------------------------------------------------
      if (client.connect(host, 80)) {
          url = PitAlarmDir + "PHP_copy.php?P1=" + FileNameLogger + "&P2="+ FileNameDummy;
          client.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
          client.stop();
          #ifdef OnPiuDebug 
            Serial.println("Copyng File");
            Serial.print(String("GET ") + url + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "Connection: close\r\n\r\n");
          #endif
      }
    #endif  
  #endif  
  delay (5000);    
}     
void PitMailSend() {
  #ifdef ESPWiFi 
    //WiFiClient client;
  #endif
  #ifdef ESP8266
    //WiFiClient client = server.available();
  #endif
  SendMsg("EHLO " + ServerName);          // say hello
  SendMsg("AUTH LOGIN ");
  SendMsg(UserName64);                    // Username
  SendMsg(Password64);                    // Password
  SendMsg("MAIL From:<" + Sender +">");   // identify sender
  SendMsg("RCPT To:<" + Recipient + ">"); // identify recipient
  SendMsg("DATA");
  SendMsg("To: " + Recipient);            // recipient in message header
  SendMsg("From: " + Sender);             // seder name in message header
  SendMsg("Subject: "+ Subject);          // insert subject
  SendMsg("");                            // empty line
  SendMsg(Body);                          // insert body
  SendMsg("");                            // empty line
  SendMsg(".");                           // end mail
  SendMsg("QUIT");                        // terminate connection
  client.println();
}
void GetResponse() {
  if (client.available()) {
    char c = client.read();
    while (client.available()) { // Store command char by char.
     ServerResponse +=c;
     c = client.read();
    }
    Serial.println("<<<" + ServerResponse);
    ServerResponse="";
  }
}
void SendMsg(String m) {
  client.println(m);
  #ifdef OnSerial     
    Serial.println(">>>" + m);
  #endif 
  delay(1000); /* wait for a response */
  GetResponse();
}
#if defined(TimeNTP)
  #ifdef OnSerial     
    void printDigits(int digits){
      // utility for digital clock display: prints preceding colon and leading 0
      Serial.print(":");
      if(digits < 10)
        Serial.print('0');
      Serial.print(digits);
    }
  #endif
#endif
#ifdef TimeNTP
    /*-------- NTP code ----------*/
    const int NTP_PACKET_SIZE = 48; // NTP time is in the first 48 bytes of message
    byte packetBuffer[NTP_PACKET_SIZE]; //buffer to hold incoming & outgoing packets
    time_t getNtpTime()
    {
      while (Udp.parsePacket() > 0) ; // discard any previously received packets
      #ifdef OnSerial     
        Serial.print(" Transmit NTP Request ... ");
      #endif
      sendNTPpacket(timeServer);
      uint32_t beginWait = millis();
      while (millis() - beginWait < 1500) { 
        int size = Udp.parsePacket();
        if (size >= NTP_PACKET_SIZE) {
          Serial.println("Receive NTP Response ok");
          Udp.read(packetBuffer, NTP_PACKET_SIZE);  // read packet into the buffer
          unsigned long secsSince1900;
          // convert four bytes starting at location 40 to a long integer
          secsSince1900 =  (unsigned long)packetBuffer[40] << 24;
          secsSince1900 |= (unsigned long)packetBuffer[41] << 16;
          secsSince1900 |= (unsigned long)packetBuffer[42] << 8;
          secsSince1900 |= (unsigned long)packetBuffer[43];
          return secsSince1900 - 2208988800UL + timeZone * SECS_PER_HOUR;
        }
      }
      #ifdef OnSerial     
        Serial.println("No NTP Response :-(");
      #endif
      return 0; // return 0 if unable to get the time
    }
    // send an NTP request to the time server at the given address
    void sendNTPpacket(IPAddress &address)
    {
      // set all bytes in the buffer to 0
      memset(packetBuffer, 0, NTP_PACKET_SIZE);
      // Initialize values needed to form NTP request
      // (see URL above for details on the packets)
      packetBuffer[0] = 0b11100011;   // LI, Version, Mode
      packetBuffer[1] = 0;     // Stratum, or type of clock
      packetBuffer[2] = 6;     // Polling Interval
      packetBuffer[3] = 0xEC;  // Peer Clock Precision
      // 8 bytes of zero for Root Delay & Root Dispersion
      packetBuffer[12]  = 49;
      packetBuffer[13]  = 0x4E;
      packetBuffer[14]  = 49;
      packetBuffer[15]  = 52;
      // all NTP fields have been given values, now
      // you can send a packet requesting a timestamp:                 
      Udp.beginPacket(address, 123); //NTP requests are to port 123
      Udp.write(packetBuffer, NTP_PACKET_SIZE);
      Udp.endPacket();
    }
    String GetDataOra () {
      // NTP Time
      prevDisplay = now();
      // digital clock display of the time
      String DataOra;
      if(day() < 10)
        DataOra = "0";
      DataOra = DataOra + String(day()) + "/";
      if(month() < 10)
        DataOra = DataOra + "0";
      DataOra = DataOra + String(month()) + "/" + String(year()) + " - ";
      if(hour() < 10)
        DataOra = DataOra + "0";
      DataOra = DataOra + String(hour()) + ":";
      if(minute() < 10)
        DataOra = DataOra + "0";
      DataOra = DataOra + String(minute()) + ":";
      if(second() < 10)
        DataOra = DataOra + "0";
      DataOra = DataOra + String(second()) + " - ";
      return (DataOra);
    }
#endif

Scarica tutto quello che serve:

ZappocoS - 26 maggio 2018