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.
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