Errore compilazione string char dopo agg libreria

[thedrifter]

Ciao,
utilizzo la libreria UniversalTelegramBot per scambio messaggi con telegram su esp32.
Ho fatto una modifica al programma, quando sono andato a compilare ho ricevuto errore: "incompatible types in assignment of 'String' to 'char [10]' forse a causa di un aggiornamento della libreria?
Ho quindi cambiato la dichiarazione delle mie variabili in string, ho compilato, ma il sistema si blocca, penso a conseguenza della string.
Ho guardato la libreria e tutte le variabili sono dichiarate come string, che soluzione posso usare?
non vorrei pubblicare il programma per le info contenute, se proprio è necessario riporterò solo alcune righe inerenti all'errore.

Grazie

[ilguargua]

@thedrifter

"incompatible types in assignment of 'String' to 'char [10]' forse a causa di un aggiornamento della libreria?

Non credo sia a causa dell'aggiornamento, prima funzionava? Perchè l'errore dice stai cercando di assegnare ad un array di char una String, e questo non si può fare, e non dipende dalla libreria.Prova ad usare il metodo toCharArray() per assegnare la stringa (oggetto della classe String ad un array di char, è fatto apposta!

Ciao, Ale.

[andreaber]

@thedrifter

"incompatible types in assignment of 'String' to 'char [10]' forse a causa di un aggiornamento della libreria?
Ho quindi cambiato la dichiarazione delle mie variabili in string, ho compilato, ma il sistema si blocca, penso a conseguenza della string.
Ho guardato la libreria e tutte le variabili sono dichiarate come string, che soluzione posso usare?

cosa hai cambiato in cosa?...da String a string o da string a String?

comunque se la riga dove ti ritorna quell'errore è una cosa tipo:

cmd[10] = (Serial.readStringUntil('.'));

penso sia perchè ti ritorna una String e non un char...però è supposizione visto che non mostri la riga con il problema...

[thedrifter]

Ricorreggo quello che ho scritto poco fa, scusatemi...

Rieccomi,
scusate, il codice è rimasto negli appunti di windows

Il programma l'ho compilato un'anno fa e funzionava correttamente, ed era questo:

char CHAT_ID[] = "*********";   // ci salvo ID della chat telegram
char chat_id[10];                 // ci salvo id letto da telegram

chat_id = String(bot.messages[i].chat_id); // verifica ID

Quello che ho corretto ora per farlo compilare è diventato così:

char CHAT_ID[] = "*********";   // ci salvo ID della chat telegram
String chat_id;                   // ci salvo id letto da telegram

chat_id = String(bot.messages[i].chat_id); // verifica ID

Il problema che si verifica ora, è che funziona per un'ora, poi non risponde più, magari risponde dopo mezz'ora dalla richiesta etc, è diventato instabile, e mi è venuto in mente fosse un problema di memoria per la String

[andreaber]

@thedrifter

bot.messages[i].chat_id

questa già ti ritorna una String...non serve il cast...

[cotestatnt]

@thedrifter

char chat_id[10]; // ci salvo id letto da telegram
chat_id = String(bot.messages[i].chat_id); // verifica ID

Questo è un errore senza se e senza ma...
Non puoi assegnare i valori ad un array in questo modo perché la variabile chat_id di fatto è un puntatore (char *)

[thedrifter]

Ok l'errore, giustamente, intanto da capire come ha compilato un'anno fa e come funzionava...
Quindi se è corretto come ho fatto ora che ho dichiarato chat_id come String, il problema che mi fa non dovrebbe essere causato da questo?
Ora non mi risponde, ho controllato nel router se veniva visualizzato, che non fosse scollegato in qualche modo, ma è connesso; quindi sapete indicarmi cosa controllare?

Grazie

[andreaber]

difficile non vedendo il codice...e potrebbe comunque esserlo anche di più vedendolo.

in questo progetto sfrutti entrambi i core dell'ESP32 con la gestione dei tasks o vai con la classica loop() che ne usa uno?
se usi la loop() e quindi hai il secondo core libero si potrebbe pensare di integrare un qualche debug che stampa su monitor seriale dove sei nel programma...non so se sto esagerando...

[thedrifter]

Si, capisco che ci vorrebbe il codice, ma essendo una cosa di gestione antifurto con dati della casa, preferirei non renderlo pubblico, dovrei fare uno sketch apposito per pubblicarlo... Non uso task, ma ho tutto il programma in loop, e non sono ancora in grado di provare qualcosa con i task...
Anche vedere il problema in seriale non è facile, ho la esp nuda alimentata e nient'altro altro, si collega in wifi al router, dovrei mettere un pc e lasciarla collegata per vedere cosa succede... Lo strano è che dopo mezz'ora o un'ora si sblocca da sola e riparte tutto.
L'unica è che riproduco una parte di codice per pubblicarlo...

[cotestatnt]

@thedrifter

essendo una cosa di gestione antifurto con dati della casa, preferirei non renderlo pubblico

Se questi sono i presupposti, fai prima a lasciare le chiavi nel portone...

Scherzi a parte, un firmware deve essere sicuro a prescindere dal sorgente.
Prendi ad esempio Linux: è l'esempio "principe" di software open source eppure è un sistema operativo estremamente sicuro (e la ragione principale è proprio perché il software è condiviso).

Se mostrare il tuo sorgente rappresenta un elemento di rischio per la sicurezza del tuo antifurto, scusami se mi permetto, ma allora non è un buon sorgente e dovresti rivederlo.

Per quanto riguarda la compilazione andata a buon fine "un anno fa", probabilmente avevi una vecchia versione del core ESP32 per Arduino.
Dico questo perché nelle ultime release, le impostazioni di compilazione sono molto più severe al punto che anche i warning vengono trattati come errori.

[thedrifter]

In effetti, con quello che hai detto mi fai riflettere
E' anche vero che sapendo che certi sistemi sono violabili, gli faccio fare cose che non possono compromettere la sicurezza, e quindi posso anche allegare lo sketch.

Tornando al problema, visto che mi hai spiegato il perchè un'anno fa è stato compilato, non capisco come mai adesso dia questo problema, io ho solo aggiunto un paio di comandi da remoto, non attribuisco a questo ...

#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>
#include <ArduinoJson.h>

#define BOTtoken "XXXXXXXXXXXX"       // utente1
char CHAT_ID[] = "YYYYYYYY";                  // utente1

#define BOTtoken_M "VVVVVVVVVVV"              // utente 2
char CHAT_ID_M[] = "ZZZZZZZZZZZ";                 // utente 2

#define RXD2      16              // definisce pin RX porta serial2
#define TXD2      17              // definisce pin TX porta serial2
#define caldaia   15              // pin relè caldaia
#define azzera     5              // pin azzera errori antifurto
#define cancello   4              // pin apre/chiude cancello princ
#define luci_sala 18              // pin comanda luci sala
#define on_lan    21              // pin comanda relè stacca lan al DVR
#define sbarra    19              // pin apre/chiude sbarra

#define PULS      34              // pin ingresso pulsante

const char* ssid = "nome_wifi";
const char* password = "passw_wifi";

String chat_id;                 // ci salvo id letto da telegram

byte puls = HIGH;                 // ci salvo la lettura del pulsante
byte n_mess = 0;                  // ci salvo il num di mess ricevuti Denis
byte n_mess1 = 0;                 // ci salvo il num di mess ricevuti Matteo
byte i = 0;                       // contatore invio mess
byte rx;                          // byte dove salvo il dato seriale letto
byte conta;                       // conta i byte letti da seriale
byte lettura[40];                 // creo 40 byte, dove salvo lettura seriale
byte volbatt = 0;                 // ci memorizzo il valore tens batteria
byte ERRORI1 = 0;                 // ci memorizzo lo stato errori, ogni bit è un sensore
byte ERRORI2 = 0;                 // ci memorizzo lo stato errori, ogni bit è un sensore
byte STATI = 0;                   // ci memorizzo lo stato delle cose, ogni bit è una cosa
byte STATI1 = 0;                  // ci memorizzo lo stato delle cose, ogni bit è una cosa
byte NEW_ERRORI1 = 0;             // ci memorizzo lo stato errori appena letto
byte NEW_ERRORI2 = 0;             // ci memorizzo lo stato errori
byte NEW_STATI = 0;               // ci memorizzo lo stato delle cose
byte NEW_STATI1 = 0;              // ci memorizzo lo stato delle cose
byte conta_porta_ingr = 0;        // i byte conta, servono a contare le volte che un sensore
byte conta_porta_off = 0;         // interviene, ed è visibile dal display
byte conta_portone = 0;
byte conta_canc_princ = 0;
byte conta_canc_salt = 0;
byte conta_barr_canc = 0;
byte conta_barr_off = 0;
byte conta_pir_porta = 0;
byte conta_pir_strada = 0;
byte conta_pir_cima_strada = 0;
byte old_conta_porta_ingr = 0;    // ci salvo vecchio stato per controllo
byte old_conta_porta_off = 0;
byte old_conta_portone = 0;
byte old_conta_canc_princ = 0;
byte old_conta_canc_salt = 0;
byte old_conta_barr_canc = 0;
byte old_conta_barr_off = 0;
byte old_conta_pir_porta = 0;
byte old_conta_pir_strada = 0;
byte old_conta_pir_cima_strada = 0;

int t_sala = 0;                   // temperatura sala
int u_sala = 0;                   // umidità sala
int t_camera = 0;                 // temperatura camera
int u_camera = 0;                 // umidità camera
int t_esterna = 0;                // temperatura esterna
int u_esterna = 0;                // umidità esterna
int t_vano = 0;                   // temperatura del sensore barometrico
int p_baro = 0;                   // pressione intero
float vbatt = 0.0;                // volt batteria, con decimali
float temp_sala = 0.0;            // temperatura sala
float umid_sala = 0.0;            // umidità sala
float temp_camera = 0.0;          // temperatura camera
float umid_camera = 0.0;          // umidità camera
float temp_esterna = 0.0;         // temperatura esterna
float umid_esterna = 0.0;         // umidità esterna
float temp_vano = 0;              // temperatura del sensore barometrico

boolean non_aggiornare = false;   // per sapere se aggiornare
boolean scritto_all = false;      // per sapere se ho scritto degli allarmi
bool pompa_azz = false;           // per sapere se ho azzerato tempo pompa acqua
bool fatto220 = false;            // per sapere se ho scritto mancanza 220
bool anti_on = false;             // per sapere se ho segnalato antifurto off
bool campan = false;              // per sapere se ho segnalato suonato campanello
bool err_camp = false;            // per sapere se rotto puls campanello
bool res_ok = false;              // per sapere se ho azzerato errori

unsigned long t_lett = 0;         // tempo per lettura da chat
unsigned long t_ser = 0;          // tempo lettura seriale
unsigned long pompa = 0;          // tempo per pompa acqua troppo accesa
unsigned long inser = 0;          // tempo attesa da attivazione antifurto

WiFiClientSecure client;
UniversalTelegramBot bot(BOTtoken, client);  
UniversalTelegramBot bot1(BOTtoken_M, client); 

void setup()
{
  Serial.begin(9600);             // Inizializzo la seriale di esp32
  Serial2.begin(9600, SERIAL_8N1, RXD2, TXD2); //seriale 2 dove leggo i dati

  pinMode(cancello, OUTPUT);
  pinMode(caldaia,  OUTPUT);
  pinMode(azzera,   OUTPUT);
  pinMode(luci_sala, OUTPUT);
  pinMode(on_lan,   OUTPUT);
  pinMode(sbarra,   OUTPUT);
  pinMode(PULS,     INPUT);

  digitalWrite(cancello, LOW);
  digitalWrite(caldaia,  LOW);
  digitalWrite(azzera,   LOW);
  digitalWrite(luci_sala, LOW);
  digitalWrite(on_lan,   LOW);
  digitalWrite(sbarra,   LOW);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  client.setCACert(TELEGRAM_CERTIFICATE_ROOT); // cert root per api.telegram.org

  while (WiFi.status() != WL_CONNECTED)
  {
    delay(1000);
    Serial.println("connessione al WI-FI...");
  }
  Serial.println(WiFi.localIP()); // scrivo IP locale dell'ESP32
  delay(200);

  bot.sendMessage(CHAT_ID, "Ciao, sono stato alimentato", "");    // invia mess Denis
  bot1.sendMessage(CHAT_ID_M, "Ciao, sono stato alimentato", ""); // invia mess Matteo

  leggi();                        // legge i dati da seriale
  bitWrite(ERRORI2, 4, 1);        // dico c'è 220 per non dare errore all'alimentazione

  t_lett = millis();              // azzero il tempo
  t_ser = millis();               // azzero il tempo
}

void loop()
{
  if (millis() - t_ser > 150)     // ogni 150 ms
  {
    leggi();                      // legge i dati da seriale

    if (millis() - inser > 180000 && anti_on == true)
    { // se trascorsi 3 minuti da att antifurto e se antifurto attivo
      if (res_ok == false)        // solo se non già fatto
      {
        digitalWrite(azzera, HIGH); // azzero eventuali errori anti
        delay(150);
        digitalWrite(azzera, LOW);
        delay(3000);                // attendo che la scheda antifurto azzeri
        aggiorna_stati();           // aggiorno a zero tutti gli stati
        res_ok = true;              // avviso che ho azzerato
      }
      controllo();                // funzione controlla sensori antifurto
    }

    t_ser = millis();             // azzero il tempo
  }

  if (millis() - t_lett > 500)    // ogni 500 ms contr mess telegram
  {
    n_mess = bot.getUpdates(bot.last_message_received + 1);
    while (n_mess)
    {
      rispondi_D(n_mess);         // risponde a Denis
      n_mess = bot.getUpdates(bot.last_message_received + 1);
    }

    n_mess1 = bot1.getUpdates(bot1.last_message_received + 1);
    while (n_mess1)
    {
      rispondi_M(n_mess1);        // risponde a Matteo
      n_mess1 = bot1.getUpdates(bot1.last_message_received + 1);
    }
    t_lett = millis();            // azzero il tempo
  }
  //_________________________________________________________________________________
  puls = digitalRead(PULS);       // leggo il pin ingresso
  if (puls == LOW)                // se è premuto il pulsante
  {
    bot.sendMessage(CHAT_ID, "E' stato premuto il puls di test, tutto funziona regolarmente!", "");
    bot1.sendMessage(CHAT_ID_M, "E' stato premuto il puls di test, tutto funziona regolarmente!", "");
    delay(500);
    while (puls == LOW)           // attendo venga rilasciato il pulsante
    {
      puls = digitalRead(PULS);   // leggo il pin ingresso
    }
  }
  //_________________________________________________________________________________
  if (bitRead (ERRORI2, 4) == 0 && fatto220 == false) // leggo il bit della 220, a 1 se c'è
  {
    bot.sendMessage(CHAT_ID, "Mancanza rete 220", "");
    bot1.sendMessage(CHAT_ID_M, "Mancanza rete 220", "");
    fatto220 = true;              // avviso che ho scritto
  }
  if (bitRead (ERRORI2, 4) == 1 && fatto220 == true) // leggo il bit della 220, a 1 se c'è
  {
    bot.sendMessage(CHAT_ID, "E' tornata la rete 220", "");
    bot1.sendMessage(CHAT_ID_M, "E' tornata la rete 220", "");
    fatto220 = false;             // avviso che ho scritto
  }
  //_________________________________________________________________________________
  if (bitRead (STATI, 2) == 1 && anti_on == false)// se antifurto on e non già fatto
  {
    if (bitRead (STATI1, 5) == 0)  // leggo il bit del portone off
    {
      bot.sendMessage(CHAT_ID, "E' stato inserito l'antifurto col portone officina aperto", "");
      bot1.sendMessage(CHAT_ID_M, "E' stato inserito l'antifurto col portone officina aperto", "");
    }
    if (bitRead (STATI1, 6) == 0)  // leggo il bit della porta ingr
    {
      bot.sendMessage(CHAT_ID, "E' stato inserito l'antifurto con la porta ingresso aperta", "");
      bot1.sendMessage(CHAT_ID_M, "E' stato inserito l'antifurto con la porta ingresso aperta", "");
    }

    if (bitRead (STATI1, 4) == 0) // leggo il bit della porta interna off
    {
      bot.sendMessage(CHAT_ID, "E' stato inserito l'antifurto con la porta interna officina aperta", "");
      bot1.sendMessage(CHAT_ID_M, "E' stato inserito l'antifurto con la porta interna officina aperta", "");
    }
    anti_on = true;               // avviso antifurto attivo
    res_ok = false;               // azzero avviso fatti azzeramenti
    inser = millis();             // carico tempo per contr sensori antifurto
  }
  if (bitRead (STATI, 2) == 0 && anti_on == true)// se antifurto off e non già fatto
  {
    bot.sendMessage(CHAT_ID, "E' stato disattivato l'antifurto!", "");
    bot1.sendMessage(CHAT_ID_M, "E' stato disattivato l'antifurto!", "");
    anti_on = false;              // avviso antifurto disattivo
  }
  //_________________________________________________________________________________

  if (bitRead (ERRORI2, 3) == 1)    // leggo il bit della pompa acqua, se accesa
  {
    if (pompa_azz == false)         // se non ho azzerato
    {
      pompa = millis();             // azzero tempo millis
      pompa_azz = true;             // avviso che ho azzerato
    }

    if (millis() - pompa > 120000)  // se passati 2 minuti
    {
      bot.sendMessage(CHAT_ID, "Pompa acqua accesa da più di 2 minuti", "");
      bot1.sendMessage(CHAT_ID_M, "Pompa acqua accesa da più di 2 minuti", "");
      pompa = millis();             // azzero tempo millis
    }
  }
  else                              // se pompa spenta
  {
    pompa_azz = false;              // azzero avviso per poterlo rifare
  }
  //_________________________________________________________________________________

  if (bitRead (ERRORI2, 1) == 1 && campan == false)// se sonato campanello e non già fatto
  {
    bot.sendMessage(CHAT_ID, "Qualcuno ha suonato il campanello", "");
    bot1.sendMessage(CHAT_ID_M, "Qualcuno ha suonato il campanello", "");
    campan = true;                      // avviso fatto suonato campanello
  }
  if (bitRead (ERRORI2, 1) == 0 && campan == true)// se campanello a riposo e non già fatto
  {
    campan = false;                     // azzero avviso suonato campanello
  }
  //_________________________________________________________________________________

  if (bitRead (ERRORI2, 2) == 1 && err_camp == false)
  { // se pulsante campanello in corto e non già fatto
    bot.sendMessage(CHAT_ID, "Pulsante campanello in corto", "");
    bot1.sendMessage(CHAT_ID_M, "Pulsante campanello in corto", "");
    err_camp = true;                      // avviso fatto errore campanello
  }
  if (bitRead (ERRORI2, 2) == 0 && err_camp == true)// se non c'è err puls camp
  {
    err_camp = false;                     // azzero avviso errore campanello
  }
  //_________________________________________________________________________________


} //OOOOOOOOOOOOOOOOOOOOOO FINE LOOP OOOOOOOOOOOOOOOOOOOOOOOOO

//**************************************************************************
void rispondi_D(byte n_mess)
{
  for (i = 0; i < n_mess; i++)
  {
    chat_id = String(bot.messages[i].chat_id); // verifica ID
    if (chat_id != CHAT_ID)       // se l'ID è diverso
    {
      bot.sendMessage(chat_id, "Utente non autorizzato!", "");
      bot.sendMessage(CHAT_ID, "Utente non autorizzato ha provato ad accedere a Denis...", "");
      bot1.sendMessage(CHAT_ID_M, "Utente non autorizzato ha provato ad accedere a Denis...", "");
      continue;
    }

    String text = bot.messages[i].text;
    String from_name = bot.messages[i].from_name;
    if (text == "/info")
    {
      String welcome = "Benvenuto Denis \n";
      welcome += "Usa questi comandi per controllare le tue uscite.\n\n";
      welcome += " /vedi allarmi antifurto \n";
      welcome += " /stati ingressi e luci di casa \n";
      welcome += " /temperature varie temperature di casa \n";

      welcome += " /accendi_caldaia accende la caldaia \n";
      welcome += " /spegni_caldaia spegne la caldaia \n";
      welcome += " /azzera pulisce gli errori antifurto \n";
      welcome += " /cancello apre/chiude il cancello \n";
      welcome += " /sbarra apre/chiude la sbarra \n";
      welcome += " /luce_off spegne luci sala \n";
      welcome += " /luce_on accende luci sala \n";
      welcome += " /luce_temp luci sala a tempo \n";
      welcome += " /stato per sapere stato delle uscite \n";
      welcome += " /ciao saluto \n";
      bot.sendMessage(CHAT_ID, welcome, "");
    }

    if (text == "/accendi_caldaia")
    {
      bot.sendMessage(CHAT_ID, "ho acceso la caldaia!", "");
      digitalWrite(caldaia, HIGH);
    }

    if (text == "/spegni_caldaia")
    {
      bot.sendMessage(CHAT_ID, "ho spento la caldaia!", "");
      digitalWrite(caldaia, LOW);
    }

    if (text == "/azzera")
    {
      digitalWrite(azzera, HIGH);
      delay(150);
      digitalWrite(azzera, LOW);
      delay(1000);                // attendo che la scheda antifurto azzeri
      aggiorna_stati();           // aggiorno a zero tutti gli stati
      bot.sendMessage(CHAT_ID, "ho azzerato gli errori antifurto!", "");
    }

    if (text == "/sbarra")
    {
      digitalWrite(sbarra, HIGH);
      delay(250);
      digitalWrite(sbarra, LOW);
      bot.sendMessage(CHAT_ID, "inviato comando sbarra", "");
    }

    if (text == "/cancello")
    {
      if (bitRead (STATI1, 7) == 0) // leggo il bit, se canc aperto
      {
        digitalWrite(cancello, HIGH);
        delay(200);
        digitalWrite(cancello, LOW);
        bot.sendMessage(CHAT_ID, "chiudo il cancello", "");
      }
      else                          // se canc chiuso
      {
        digitalWrite(cancello, HIGH);
        delay(200);
        digitalWrite(cancello, LOW);
        bot.sendMessage(CHAT_ID, "apro il cancello", "");
      }
    }

    if (text == "/luce_off")
    {
      if (bitRead (ERRORI2, 6) == 1)     // leggo il bit della luce sala
      { // se accesa
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);
        bot.sendMessage(CHAT_ID, "ho spento la luce di sala!", "");
      }
      else    // se già spenta
      {
        bot.sendMessage(CHAT_ID, "la luce di sala è già spenta!!!", "");
      }
    }

    if (text == "/luce_on")
    {
      if (bitRead (ERRORI2, 6) == 0)     // leggo il bit della luce sala
      { // se spenta
        digitalWrite(luci_sala, HIGH);
        delay(100);
        digitalWrite(luci_sala, LOW);
        bot.sendMessage(CHAT_ID, "ho acceso la luce di sala!", "");
      }
      else    // se è già accesa
      {
        bot.sendMessage(CHAT_ID, "la luce di sala è già accesa!!!", "");
      }
    }

    if (text == "/luce_temp")
    {
      if (bitRead (ERRORI2, 6) == 0)     // leggo il bit della luce sala
      { // se spenta
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);
        bot.sendMessage(CHAT_ID, "ho acceso la luce di sala a tempo!", "");
      }
      else  // se accesa
      {
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);   // spengo la luce
        delay(800);                     // attendo
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);   // riaccendo a tempo
        bot.sendMessage(CHAT_ID, "ho acceso la luce sala a tempo!", "");
      }
    }

    if (text == "/temperature")
    {
      String welcome = "Ecco le temperature di casa: \n\n";
      welcome += "Temperatura sala = ";
      welcome += temp_sala;
      welcome += "\n";
      welcome += "Umidità sala = ";
      welcome += umid_sala;
      welcome += "\n";
      welcome += "Temperatura camera = ";
      welcome += temp_camera;
      welcome += "\n";
      welcome += "Umidità camera = ";
      welcome += umid_camera;
      welcome += "\n";
      welcome += "Temperatura esterna = ";
      welcome += temp_esterna;
      welcome += "\n";
      welcome += "Umidità esterna = ";
      welcome += umid_esterna;
      welcome += "\n";
      welcome += "Temperatura vano tecnico = ";
      welcome += temp_vano;
      welcome += "\n";
      welcome += "Pressione barometrica = ";
      welcome += p_baro;
      bot.sendMessage(CHAT_ID, welcome, "");
    }

    if (text == "/vedi")
    {
      String welcome = "Ecco i dati richiesti: \n\n";
      welcome += "PIR cima strada = ";
      welcome += conta_pir_cima_strada;
      welcome += "\n";
      welcome += "PIR strada camera = ";
      welcome += conta_pir_strada;
      welcome += "\n";
      welcome += "PIR davanti porta ingr. = ";
      welcome += conta_pir_porta;
      welcome += "\n";
      welcome += "Barriera cancello = ";
      welcome += conta_barr_canc;
      welcome += "\n";
      welcome += "Barriera officina = ";
      welcome += conta_barr_off;
      welcome += "\n";

      if (bitRead (STATI1, 6) == 0)  // leggo il bit della porta ingr
      {
        welcome += "Porta ingresso APERTA ";
      }
      else
      {
        welcome += "Porta ingresso chiusa ";
      }
      welcome += conta_porta_ingr;
      welcome += "\n";

      if (bitRead (STATI1, 5) == 0)  // leggo il bit del portone off
      {
        welcome += "Portone officina APERTO ";
      }
      else
      {
        welcome += "Portone officina chiuso ";
      }
      welcome += conta_portone;
      welcome += "\n";

      if (bitRead (STATI1, 4) == 0) // leggo il bit della porta interna off
      {
        welcome += "Porta interna off APERTA ";
      }
      else
      {
        welcome += "Porta interna off chiusa ";
      }
      welcome += conta_porta_off;
      welcome += "\n";

      if (bitRead (STATI1, 7) == 0) // leggo il bit del canc aperto
      {
        welcome += "Cancello principale APERTO ";
      }
      else
      {
        welcome += "Cancello principale chiuso ";
      }
      welcome += conta_canc_princ;
      welcome += "\n";

      if (bitRead (STATI1, 3) == 0) // leggo il bit del canc salt aperto
      {
        welcome += "Cancello salt APERTO ";
      }
      else
      {
        welcome += "Cancello salt chiuso ";
      }
      welcome += conta_canc_salt;

      bot.sendMessage(CHAT_ID, welcome, "");
    }

    if (text == "/stati")
    {
      String welcome = "Ecco i dati richiesti: \n\n";
      welcome += "Tensione batteria = ";
      welcome += vbatt;
      welcome += "\n";

      if (bitRead (STATI, 0) == 1)       // leggo il bit del crepuscolare
      {
        welcome += "Il crepuscolare vede NOTTE";
      }
      else
      {
        welcome += "Il crepuscolare vede giorno";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 4) == 1)     // leggo il bit della 220, a 1 se c'è
      {
        welcome += "Rete 220 presente";
      }
      else
      {
        welcome += "Mancanza rete 220V";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 3) == 1)     // leggo il bit della pompa acqua
      {
        welcome += "Pompa acqua ACCESA";
      }
      else
      {
        welcome += "Pompa acqua spenta";
      }
      welcome += "\n";

      if (bitRead (STATI, 2) == 1)       // leggo il bit dell'antifurto
      {
        welcome += "Antifurto ATTIVO";
      }
      else
      {
        welcome += "Antifurto non attivo";
      }
      welcome += "\n";

      if (bitRead (STATI, 7) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne davanti ACCESE";
      }
      else
      {
        welcome += "Luci esterne davanti spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 6) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne dietro ACCESE";
      }
      else
      {
        welcome += "Luci esterne dietro spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 5) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne camera ACCESE";
      }
      else
      {
        welcome += "Luci esterne camera spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 4) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne porta ACCESE";
      }
      else
      {
        welcome += "Luci esterne porta spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 3) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne campo ACCESE";
      }
      else
      {
        welcome += "Luci esterne campo spente";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 6) == 1)     // leggo il bit della luce sala
      {
        welcome += "Luci sala ACCESE";
      }
      else
      {
        welcome += "Luci sala spente";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 5) == 1)     // leggo il bit della luce officina
      {
        welcome += "Luci officina ACCESE";
      }
      else
      {
        welcome += "Luci officina spente";
      }

      bot.sendMessage(CHAT_ID, welcome, "");
    }

    if (text == "/ciao")
    {
      bot.sendMessage(CHAT_ID, "Ciao Denis, come posso aiutarti ? ", "");
    }

    if (text == "/stato")
    {
      if (digitalRead(caldaia))
      {
        bot.sendMessage(CHAT_ID, "la caldaia è accesa!", "");
      }
      else
      {
        bot.sendMessage(CHAT_ID, "la caldaia è spenta!", "");
      }

      if (digitalRead(on_lan))
      {
        bot.sendMessage(CHAT_ID, "il DVR è collegato in rete!", "");
      }
      else
      {
        bot.sendMessage(CHAT_ID, "il DVR non è connesso alla rete!", "");
      }
    }
  }
}

//**************************************************************************
void rispondi_M(byte n_mess)    // funzione risponde a Matteo
{
  for (i = 0; i < n_mess; i++)
  {
    chat_id = String(bot1.messages[i].chat_id); // verifica ID
    if (chat_id != CHAT_ID_M)       // se l'ID è diverso
    {
      bot.sendMessage(chat_id, "Utente non autorizzato!", "");
      bot.sendMessage(CHAT_ID, "Utente non autorizzato ha provato ad accedere a Matteo...", "");
      bot1.sendMessage(CHAT_ID_M, "Utente non autorizzato ha provato ad accedere a Matteo...", "");
      continue;
    }

    String text = bot1.messages[i].text;
    String from_name = bot1.messages[i].from_name;
    if (text == "/info")
    {
      String welcome = "Benvenuto Matteo \n";
      welcome += "Usa questi comandi per controllare le tue uscite.\n\n";
      welcome += " /vedi allarmi antifurto \n";
      welcome += " /stati ingressi e luci di casa \n";
      welcome += " /temperature varie temperature di casa \n";

      welcome += " /accendi_caldaia accende la caldaia \n";
      welcome += " /spegni_caldaia spegne la caldaia \n";
      welcome += " /azzera pulisce gli errori antifurto \n";
      welcome += " /cancello apre/chiude il cancello \n";
      welcome += " /sbarra apre/chiude la sbarra \n";
      welcome += " /luce_off spegne luci sala \n";
      welcome += " /luce_on accende luci sala \n";
      welcome += " /luce_temp luci sala a tempo \n";
      welcome += " /stato per sapere stato delle uscite \n";
      welcome += " /ciao saluto \n";
      bot1.sendMessage(CHAT_ID_M, welcome, "");
    }

    if (text == "/accendi_caldaia")
    {
      bot1.sendMessage(CHAT_ID_M, "ho acceso la caldaia!", "");
      bot.sendMessage(CHAT_ID, "Matteo ha acceso la caldaia!", "");
      digitalWrite(caldaia, HIGH);
    }

    if (text == "/spegni_caldaia")
    {
      bot1.sendMessage(CHAT_ID_M, "ho spento la caldaia!", "");
      bot.sendMessage(CHAT_ID, "Matteo ha spento la caldaia!", "");
      digitalWrite(caldaia, LOW);
    }

    if (text == "/azzera")
    {
      digitalWrite(azzera, HIGH);
      delay(150);
      digitalWrite(azzera, LOW);
      delay(1000);                // attendo che la scheda antifurto azzeri
      aggiorna_stati();           // aggiorno a zero tutti gli stati
      bot1.sendMessage(CHAT_ID_M, "ho azzerato gli errori antifurto!", "");
    }

    if (text == "/sbarra")
    {
      digitalWrite(sbarra, HIGH);
      delay(250);
      digitalWrite(sbarra, LOW);
      bot1.sendMessage(CHAT_ID_M, "inviato comando sbarra", "");
      bot.sendMessage(CHAT_ID, "Matteo ha inviato comando sbarra", "");
    }

    if (text == "/cancello")
    {
      if (bitRead (STATI1, 7) == 0) // leggo il bit, se canc aperto
      {
        digitalWrite(cancello, HIGH);
        delay(200);
        digitalWrite(cancello, LOW);
        bot1.sendMessage(CHAT_ID_M, "chiudo il cancello", "");
        bot.sendMessage(CHAT_ID, "Matteo ha chiuso il cancello", "");
      }
      else                          // se canc chiuso
      {
        digitalWrite(cancello, HIGH);
        delay(200);
        digitalWrite(cancello, LOW);
        bot1.sendMessage(CHAT_ID_M, "apro il cancello", "");
        bot.sendMessage(CHAT_ID, "Matteo ha aperto il cancello", "");
      }
    }

    if (text == "/luce_off")
    {
      if (bitRead (ERRORI2, 6) == 1)     // leggo il bit della luce sala
      { // se accesa
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);
        bot1.sendMessage(CHAT_ID_M, "ho spento la luce di sala!", "");
        bot.sendMessage(CHAT_ID, "Matteo ha spento la luce di sala!", "");
      }
      else    // se già spenta
      {
        bot1.sendMessage(CHAT_ID_M, "la luce di sala è già spenta!!!", "");
      }

    }

    if (text == "/luce_on")
    {
      if (bitRead (ERRORI2, 6) == 0)     // leggo il bit della luce sala
      { // se spenta
        digitalWrite(luci_sala, HIGH);
        delay(100);
        digitalWrite(luci_sala, LOW);
        bot1.sendMessage(CHAT_ID_M, "ho acceso la luce di sala!", "");
        bot.sendMessage(CHAT_ID, "Matteo ha acceso la luce di sala!", "");
      }
      else    // se è già accesa
      {
        bot1.sendMessage(CHAT_ID_M, "la luce di sala è già accesa!!!", "");
      }
    }

    if (text == "/luce_temp")
    {
      if (bitRead (ERRORI2, 6) == 0)     // leggo il bit della luce sala
      { // se spenta
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);
        bot1.sendMessage(CHAT_ID_M, "ho acceso la luce di sala a tempo!", "");
        bot.sendMessage(CHAT_ID, "Matteo ha acceso la luce di sala a tempo!", "");
      }
      else  // se accesa
      {
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);   // spengo la luce
        delay(800);                     // attendo
        digitalWrite(luci_sala, HIGH);
        delay(800);
        digitalWrite(luci_sala, LOW);   // riaccendo a tempo
        bot1.sendMessage(CHAT_ID_M, "accesa luce sala a tempo!", "");
        bot.sendMessage(CHAT_ID, "Matteo ha acceso la luce di sala a tempo!", "");
      }
    }

    if (text == "/temperature")
    {
      String welcome = "Ecco le temperature di casa: \n\n";
      welcome += "Temperatura sala = ";
      welcome += temp_sala;
      welcome += "\n";
      welcome += "Umidità sala = ";
      welcome += umid_sala;
      welcome += "\n";
      welcome += "Temperatura camera = ";
      welcome += temp_camera;
      welcome += "\n";
      welcome += "Umidità camera = ";
      welcome += umid_camera;
      welcome += "\n";
      welcome += "Temperatura esterna = ";
      welcome += temp_esterna;
      welcome += "\n";
      welcome += "Umidità esterna = ";
      welcome += umid_esterna;
      welcome += "\n";
      welcome += "Temperatura vano tecnico = ";
      welcome += temp_vano;
      welcome += "\n";
      welcome += "Pressione barometrica = ";
      welcome += p_baro;
      bot1.sendMessage(CHAT_ID_M, welcome, "");
    }

    if (text == "/vedi")
    {
      String welcome = "Ecco i dati richiesti: \n\n";
      welcome += "PIR cima strada = ";
      welcome += conta_pir_cima_strada;
      welcome += "\n";
      welcome += "PIR strada camera = ";
      welcome += conta_pir_strada;
      welcome += "\n";
      welcome += "PIR davanti porta ingr. = ";
      welcome += conta_pir_porta;
      welcome += "\n";
      welcome += "Barriera cancello = ";
      welcome += conta_barr_canc;
      welcome += "\n";
      welcome += "Barriera officina = ";
      welcome += conta_barr_off;
      welcome += "\n";

      if (bitRead (STATI1, 6) == 0)  // leggo il bit della porta ingr
      {
        welcome += "Porta ingresso APERTA ";
      }
      else
      {
        welcome += "Porta ingresso chiusa ";
      }
      welcome += conta_porta_ingr;
      welcome += "\n";

      if (bitRead (STATI1, 5) == 0)  // leggo il bit del portone off
      {
        welcome += "Portone officina APERTO ";
      }
      else
      {
        welcome += "Portone officina chiuso ";
      }
      welcome += conta_portone;
      welcome += "\n";

      if (bitRead (STATI1, 4) == 0) // leggo il bit della porta interna off
      {
        welcome += "Porta interna off APERTA ";
      }
      else
      {
        welcome += "Porta interna off chiusa ";
      }
      welcome += conta_porta_off;
      welcome += "\n";

      if (bitRead (STATI1, 7) == 0) // leggo il bit del canc aperto
      {
        welcome += "Cancello principale APERTO ";
      }
      else
      {
        welcome += "Cancello principale chiuso ";
      }
      welcome += conta_canc_princ;
      welcome += "\n";

      if (bitRead (STATI1, 3) == 0) // leggo il bit del canc salt aperto
      {
        welcome += "Cancello salt APERTO ";
      }
      else
      {
        welcome += "Cancello salt chiuso ";
      }
      welcome += conta_canc_salt;

      bot1.sendMessage(CHAT_ID_M, welcome, "");
    }

    if (text == "/stati")
    {
      String welcome = "Ecco i dati richiesti: \n\n";
      welcome += "Tensione batteria = ";
      welcome += vbatt;
      welcome += "\n";

      if (bitRead (STATI, 0) == 1)       // leggo il bit del crepuscolare
      {
        welcome += "Il crepuscolare vede NOTTE";
      }
      else
      {
        welcome += "Il crepuscolare vede giorno";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 4) == 1)     // leggo il bit della 220, a 1 se c'è
      {
        welcome += "Rete 220 presente";
      }
      else
      {
        welcome += "Mancanza rete 220V";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 3) == 1)     // leggo il bit della pompa acqua
      {
        welcome += "Pompa acqua ACCESA";
      }
      else
      {
        welcome += "Pompa acqua spenta";
      }
      welcome += "\n";

      if (bitRead (STATI, 2) == 1)       // leggo il bit dell'antifurto
      {
        welcome += "Antifurto ATTIVO";
      }
      else
      {
        welcome += "Antifurto non attivo";
      }
      welcome += "\n";

      if (bitRead (STATI, 7) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne davanti ACCESE";
      }
      else
      {
        welcome += "Luci esterne davanti spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 6) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne dietro ACCESE";
      }
      else
      {
        welcome += "Luci esterne dietro spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 5) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne camera ACCESE";
      }
      else
      {
        welcome += "Luci esterne camera spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 4) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne porta ACCESE";
      }
      else
      {
        welcome += "Luci esterne porta spente";
      }
      welcome += "\n";

      if (bitRead (STATI, 3) == 1)       // leggo il bit della luce fuori
      {
        welcome += "Luci esterne campo ACCESE";
      }
      else
      {
        welcome += "Luci esterne campo spente";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 6) == 1)     // leggo il bit della luce sala
      {
        welcome += "Luci sala ACCESE";
      }
      else
      {
        welcome += "Luci sala spente";
      }
      welcome += "\n";

      if (bitRead (ERRORI2, 5) == 1)     // leggo il bit della luce officina
      {
        welcome += "Luci officina ACCESE";
      }
      else
      {
        welcome += "Luci officina spente";
      }

      bot1.sendMessage(CHAT_ID_M, welcome, "");
      bot.sendMessage(CHAT_ID, "Matteo ha guardato gli stati", "");
    }

    if (text == "/ciao")
    {
      bot1.sendMessage(CHAT_ID_M, "Ciao Matteo, come posso aiutarti ?", "");
    }

    if (text == "/stato")
    {
      if (digitalRead(caldaia))
      {
        bot1.sendMessage(CHAT_ID_M, "la caldaia è accesa!", "");
      }
      else
      {
        bot1.sendMessage(CHAT_ID_M, "la caldaia è spenta!", "");
      }

      if (digitalRead(on_lan))
      {
        bot1.sendMessage(CHAT_ID_M, "il DVR è collegato in rete!", "");
      }
      else
      {
        bot1.sendMessage(CHAT_ID_M, "il DVR non è connesso alla rete!", "");
      }
    }
  }
}

//********************************************************************
void leggi()                                // leggo la seriale
{
  conta = 0;                                // azzero contatore byte ricevuti
  while (Serial2.available())               // svuota tutto il buffer
  {
    rx = Serial2.read();                    // salva il byte letto da seriale
    if (conta < 31)
    {
      lettura[conta] = rx;                  // memorizza max 31 byte
    }
    conta++;                                // ma conta tutti i byte ricevuti
  }
  if (conta == 31)                          // se ricevuti esattamente 31
  {
    // ****** converto i 2 byte in un intero ********
    t_sala = lettura[1] * 256 + lettura[0]; // 1° byte H, 2° byte L
    u_sala = lettura[3] * 256 + lettura[2];
    t_camera = lettura[5] * 256 + lettura[4];
    u_camera = lettura[7] * 256 + lettura[6];
    t_esterna = lettura[9] * 256 + lettura[8];
    u_esterna = lettura[11] * 256 + lettura[10];
    t_vano = lettura[13] * 256 + lettura[12];
    p_baro = lettura[15] * 256 + lettura[14];
    volbatt = lettura[16];
    NEW_ERRORI1 = lettura[17];
    NEW_ERRORI2 = lettura[18];
    NEW_STATI = lettura[19];
    NEW_STATI1 = lettura[20];
    conta_porta_ingr = lettura[21];
    conta_portone = lettura[22];
    conta_porta_off = lettura[23];
    conta_canc_princ = lettura[24];
    conta_canc_salt = lettura[25];
    conta_barr_off = lettura[26];
    conta_barr_canc = lettura[27];
    conta_pir_porta = lettura[28];
    conta_pir_strada = lettura[29];
    conta_pir_cima_strada = lettura[30];

    vbatt = volbatt / 10.0;                 // divido per 10 per vedere la virgola
    temp_sala = t_sala / 100.0;             // divido per 100 e converto in float
    umid_sala = u_sala / 100.0;
    temp_camera = t_camera / 100.0;
    umid_camera = u_camera / 100.0;
    temp_esterna = t_esterna / 100.0;
    umid_esterna = u_esterna / 100.0;
    temp_vano = t_vano / 100.0;

    if (NEW_ERRORI1 == ERRORI1 && NEW_ERRORI2 == ERRORI2 && NEW_STATI == STATI && NEW_STATI1 == STATI1)
    {
      non_aggiornare = true;              // dico di non aggiornare il display
    }
    else
    {
      non_aggiornare = false;             // dico di aggiornare il display
      ERRORI1 = NEW_ERRORI1;              // aggiorno le variabili
      ERRORI2 = NEW_ERRORI2;
      STATI = NEW_STATI;
      STATI1 = NEW_STATI1;
    }
  }
}
//********************************************************************
void controllo()                  // verifico se c'è un allarme
{
  if (conta_porta_ingr != old_conta_porta_ingr)   // contr porta ingresso
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "apertura porta ingresso n.";
    welcome += conta_porta_ingr;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_porta_ingr = conta_porta_ingr;    // salvo il nuovo valore
  }

  if (conta_porta_off != old_conta_porta_off)   // contr porta officina
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "apertura porta interna officina n.";
    welcome += conta_porta_off;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_porta_off = conta_porta_off;      // salvo il nuovo valore
  }

  if (conta_portone != old_conta_portone)       // contr portone officina
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "apertura portone officina n.";
    welcome += conta_portone;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_portone = conta_portone;          // salvo il nuovo valore
  }

  if (conta_canc_princ != old_conta_canc_princ) // contr cancello princ
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "apertura cancello n.";
    welcome += conta_canc_princ;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_canc_princ = conta_canc_princ;    // salvo il nuovo valore
  }

  if (conta_canc_salt != old_conta_canc_salt)   // contr cancello salt
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "apertura cancello SALT n.";
    welcome += conta_canc_salt;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_canc_salt = conta_canc_salt;      // salvo il nuovo valore
  }

  if (conta_barr_canc != old_conta_barr_canc)   // contr barriera cancello
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "barriera cancello n.";
    welcome += conta_barr_canc;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_barr_canc = conta_barr_canc;      // salvo il nuovo valore
  }

  if (conta_barr_off != old_conta_barr_off)     // contr barriera officina
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "barriera officina n.";
    welcome += conta_barr_off;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_barr_off = conta_barr_off;        // salvo il nuovo valore
  }

  if (conta_pir_porta != old_conta_pir_porta)   // contr pir davanti porta
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "PIR davanti porta n.";
    welcome += conta_pir_porta;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_pir_porta = conta_pir_porta;      // salvo il nuovo valore
  }

  if (conta_pir_strada != old_conta_pir_strada) // contr barriera davanti camera
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "barriera strada n.";
    welcome += conta_pir_strada;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_pir_strada = conta_pir_strada;    // salvo il nuovo valore
  }

  if (conta_pir_cima_strada != old_conta_pir_cima_strada) // contr barriera cima strada
  {
    String welcome = "Si è verificato un allarme a casa: \n\n";
    welcome += "barriera in cima alla strada n.";
    welcome += conta_pir_cima_strada;
    bot.sendMessage(CHAT_ID, welcome, "");
    bot1.sendMessage(CHAT_ID_M, welcome, "");
    old_conta_pir_cima_strada = conta_pir_cima_strada;    // salvo il nuovo valore
  }
}
//********************************************************************
void aggiorna_stati()   // aggiorna tutti gli stati a zero
{
  old_conta_pir_cima_strada = 0;
  old_conta_pir_strada = 0;
  old_conta_pir_porta = 0;
  old_conta_barr_off = 0;
  old_conta_barr_canc = 0;
  old_conta_canc_salt = 0;
  old_conta_canc_princ = 0;
  old_conta_portone = 0;
  old_conta_porta_off = 0;
  old_conta_porta_ingr = 0;

  conta_pir_cima_strada = 0;
  conta_pir_strada = 0;
  conta_pir_porta = 0;
  conta_barr_off = 0;
  conta_barr_canc = 0;
  conta_canc_salt = 0;
  conta_canc_princ = 0;
  conta_portone = 0;
  conta_porta_off = 0;
  conta_porta_ingr = 0;
}

[cotestatnt]

Sono riuscito solo a dargli una rapida guardata fino ad ora, ma un paio di cose mi saltano all'occhio.

Ci sono tante String è vero, ma sono per la maggior parte dichiarate localmente e correttamente concatenate evitando la creazione di inutili copie.
Io non credo che la ragione del malfunzionamento che riscontri sia da ricercarsi in questo.

Potresti usare un gruppo in cui aggiungi i due utenti invece di usare due bot distinti e dimezzare il codice necessario per gestirne due al posto di uno.
Nel caso in cui questo non fosse possibile per le vostre ragioni, io userei due WiFiClientSecure client distinti da associare a ciascun bot.

La mia ipotesi è quella che i due bot si possano "rubare" byte l'uno con l'altro perché condividono lo stesso client.
Come detto, io userei un solo bot che scrive ad un gruppo eventualmente discriminando le risposte da dare in funzione dell'utente che sta inviando i messaggi.

Prova anche a misurare lo spazio disponibile nell'heap, se vedi che i blocchi di memoria disponibili diminuiscono progressivamente, allora significa che hai frammentazione o cosiddetti "memory leaks". Io uso sempre questa funzione richiamata nel loop() per verificare che il comportamento sia stabile nel tempo.

void printHeapStats() {
  static uint32_t infoTime;
  if (millis() - infoTime > 5000) {
    infoTime = millis();
    Serial.printf("Total free: %6d - Max block: %6d\n",
                 heap_caps_get_free_size(0), heap_caps_get_largest_free_block(0) );
  }
}

[andreaber]

andrebbe capito se il problema del "blocco" è perchè si è entrati in un "loop" dal quale non si riesce ad uscire (while, for...) o, come dice cotestatnt, un problema di gestione "invio dati"...per il primo potresti usare il "led" già presente nell'ESP32 per segnalae che il programma sta ciclando e non è "bloccato" in qualche punto.
per il secondo...anche implementando quanto suggerito da cotestatnt, temporizzi i due invii messaggio in modo da non averli uno subito dopo l'altro...

[thedrifter]

Ciao,
grazie per le info, anche se continuo a non capire come mai fino ad ora abbia sempre funzionato bene, sebbene questi "errori" fossero sempre presenti...
Per rispondere ad andreaber, non dovrebbe essere un blocco nel loop in quanto esce da solo da questo blocco, inoltre il led a bordo che è utilizzato dal wifi continua a lampeggiare... Posso comunque montare un'altro led su un'altro gpio (perchè quello a bordo è utilizzato dalla libreria wifi) e verificare comunque cosa accade.
Inoltre implemento il codice suggerito da cotestatnt per visualizzare il comportamento.
Per quanto riguarda i 2 bot, non saprei come fare per usarne uno solo e scrivere a un gruppo, intanto provo a differenziare le wificlientsecure
Grazie

[cotestatnt]

@thedrifter

continuo a non capire come mai fino ad ora abbia sempre funzionato

Lo hai scritto tu stesso, ha smesso di funzionare dopo l'aggiornamento della libreria che evidentemente per come era scritta prima era più tollerante a questo tipo di errori.

Nel frattempo anche il core esp32 per Arduino ha subito importanti aggiornamenti.

Purtroppo quando succedono cose come queste, le strade sono due: rimboccarsi le maniche e modificare il firmware per adeguarlo alle nuove versioni oppure congelare il sorgente ad una determinata versione di librerie e core.

Questa seconda ipotesi purtroppo con Arduino ide è abbastanza laboriosa perché o usi la vecchia versione 1.x creando una installazione portable, oppure fai una copia locale delle librerie usate nella sottocartella src creata nella cartella principale dello sketch, andando poi a includere le librerie usando il percorso locale.

[cotestatnt]

@thedrifter

non saprei come fare per usarne uno solo e scrivere a un gruppo

E' esattamente la stessa cosa che scrivere ad un utente, solo che il gruppo ha sempre un id che è un numero negativo.

La maggior parte del lavoro va fatta lato Telegram dove dovrai:

• creare il gruppo
• aggiungere tutti gli utenti che ne fanno parte
• aggiungere il bot come admin (altrimenti non può scrivere)
• recuperare l'id del gruppo (ad esempio aggiungendo questo bot al gruppo https://t.me/JsonDumpBot: manderà un messaggio JSON con tutte le caratteristiche del gruppo e poi lo puoi rimuovere)

Nel firmware ESP32 puoi recuperare l'ID dell'utente che scrive nel gruppo esattamente come fai adesso (proprio perché non ci sono differenze rispetto ad una chat uno ad uno.
Magari a quel punto potresti rendere dinamica la gestione degli utenti autorizzati implementando la rimozione e l'aggiunta degli id associati (o magari username che sono più facili da ricordare) direttamente usando il bot e non staticamente nel firmware come fai adesso.

[thedrifter]

Ok,
avevo capito che avevo pensato male a dar colpa all'aggiornamento delle librerie, invece è così
Mi metto al lavoro, intanto metto led e il programma di verifica, poi per capire se si intralciano i bot non posso anche eliminarne uno per adesso? Farei prima
Comunque proverò anche il discorso gruppo

[cotestatnt]

@thedrifter

intanto metto led

Se vuoi far lampeggiare un led, tieni conto che le chiamate alla libreria UniversalTelegramBot sono bloccanti fino a quando il server Telegram non avrà risposto o va in timeout e quindi avrai un lampeggio molto irregolare (è una delle ragioni principali che mi hanno spinto a sviluppare la mia libreria Telegram che non soffre di questo comportamento, o meglio lo fa in modo quasi impercettibile).

Visto che usi ESP32, una soluzione rapida sarebbe quella di spostare il codice che si occupa di recuperare i messaggi dal server Telegram su un task dedicato da far girare in parallelo a loop()

[thedrifter]

Ciao,
ho seguito i suggerimenti, per quanto riguarda il led lampeggiante nel loop, lo trovo molto rallentato anche se non viene utilizata la chat telegram, ho messo un on/off ogni secondo, ma diciamo che quasi sempre è ogni 4 o 5 secondi.
Per quanto riguarda la memoria, in seriale leggo un valore sempre intorno ai 252500, oscilla poco +/-.
Aggiungo anche che ho un continuo lampeggiare del led usato dalla libreria wifi, non dovrebbe esserci poca attività quando non utilizzata la chat?
Ora vedo di separare i wificlientsecure...

[andreaber]

ciao

il LED che lampeggia ogni 4-5 secondi anzichè ogni 1 come hai messo tu indica che il programma ha parti bloccanti, già segnalato da cotestatnt qualche post fa.
Non conosco bene la libreira "universaltelrgramBot"...mi sembra però che le varie funzioni "sendmessage" ritornino un bool...a cosa si riferisce quel bool?...c'è modo di capire se il "pacchetto" è stato inviato correttamente e se si può inviarne un altro senza problemi?