[Risolto]Cronotermostato con esp8266-01s comandato da BOT TELEGRAM

Salve a tutti;
Per prima cosa voglio augurare a tutto il forum un buon fine anno e un felice 2020.

Dunque, come da oggetto ho realizzato un cronotermostato utilizzando un esp8266-01s, un stm32f103c8t6 e un display lcd5110 e questo e lo sketch relativo a esp8266-01s:

/*
  Name              : TelegramBot.ino
  Nome BOT telegram : CronoTermo
  Creato            : 17/12/2019
  Autore            : Amedeo Di Vito <amedeodivito@gmail.com>
  Librerie          : CTBot V 1.40, arduinojson (Versione 5.13.5 con versioni superiori non funziona)
  Hardware          : esp8266-01s - stm32f103c8t6 - display lcd5110
  Descrizione       : esempio di come funziona
                      1) riceve un messaggio
                      2) se riceve un comando valido lo esegue e lo notifica al mittente
                      3) altrimenti invia un messaggio al mittente con la spiegazione dei comandi
                      4) 2 utenti abilitati, ma se ne possono aggiungere altri
*/
#include "CTBot.h"
#include <Esp.h>

#define LED 2
#define LOOP 5

CTBot myBot;

uint32_t amedeo  = mia id;             // la tua ID di aministratore del BOT
uint32_t daniela = altra id;              // la tua ID di utente abilitato
String ssid = "ssid";                        // la ssid della rete Wi-Fi
String pass = "password";               // la password della rete Wi-Fi
String token = "token del BOT";       // sostituire con il proprio token
String comando;
String dati;
byte   verifica = LOOP;                                           // loop prima della verifica
char   *emoticon;

void setup() {
  delay(1000);
  Serial.begin(115200);
  pinMode(LED, OUTPUT);
  ESP.wdtDisable();                                              // disabilita SW WDT
  lampeggia(20);                                                 // il led esp8266 lampeggia n volte
  myBot.wifiConnect(ssid, pass);                                 // connessione alla rete Wi-Fi
  myBot.setTelegramToken(token);                                 // imposta il token di telegram
}

void loop() {
  emoticon = " \xE2\x9C\x85"; // OK                              // reimposta emoticon di default
  TBMessage msg;                                                 // variabili contenenti i dati del messaggio
  chkSerial(msg.sender.id);                                      // verifica disponibilita nuovo messaggio seriale da stm32f103c8t6

  if (LOOP == verifica) {                                        // dopo 10 loop verifica la connessione
    verifica = 0;
    testConnessione();
  }

  // se arriva un nuovo messaggio...
  if (myBot.getNewMessage(msg) &&
      ( msg.sender.id == amedeo ||
        msg.sender.id == daniela ))
  {
    comando = msg.text.substring(0, 4);                          // divide il comando dai dati
    dati    = msg.text.substring(4, msg.text.length());

    if (comando == "/inf" ||
        comando == "/acc" ||
        comando == "/spe" ||
        comando == "/tem" ||
        comando == "/led" ||
        comando == "/ora")   {
      Serial.println(msg.text);                                  // invia il comando
    }
    else if (comando == "/hel") help(msg.sender.id);             // invia la lista dei comandi
    else {
      emoticon = "\xE2\x9A\xA0";                                 // emoticon HELP
      dati = "Ciao " + String(msg.sender.firstName) + ";\nMemoria disponibile: " + String(ESP.getFreeHeap()) + "\nPer la lista dei comandi:\nPREMI \"/help\"       " + emoticon;
      myBot.sendMessage(msg.sender.id, dati);                    // notifica i comandi al mittente
    }
  }

  delayMicroseconds(500000);
  yield();
  ESP.wdtFeed();                                                 // alimenta il watchdog
  verifica++;
  lampeggia(1);                                                  // il led esp8266 lampeggia n volte
}

// ****************************************************************************************
// chkSerial() - VERIFICA/RICEVE I DATI RICHIESTI TRAMITE BOT TELEGRAM
// ****************************************************************************************
void chkSerial(uint32_t utente) {
  int disponibili = Serial.available();
  if (disponibili > 0) {
    char c;
    String buf = "";
    if (Serial.read() != '#') {                                // se primo carattere diverso da "#" il flusso non e' valido
      clearSerialBuffer();
      return;
    }
    for (int ciclo = 1; ciclo <= disponibili - 3; ciclo++) {   // esclude # iniziale  e # CRLF finale
      c = Serial.read();
      if (c != '#') {
        buf += c;
      }
      delay(10);                                               // delay() alimenta HW WDT
    }
    if (c != '#') {                                            // se non e' # rifiuta il messaggio
      buf = "** ERRORE RICEZIONE DATI **";
      emoticon = "\xF0\x9F\x98\xA9"; // ERRORE
    }
    clearSerialBuffer();                                       // svuota il buffer della seriale
    if (buf == "CALDAIA ACCESA A MANO" || buf == "CALDAIA SPENTA A MANO") {  // ipotetica accensione con pulsante fisico
      utente = amedeo;                                         // in tal caso notifica solo a me
    }
    myBot.sendMessage(utente, buf + emoticon);                 // e invia notifica al mittente
  }
}

// ****************************************************************************************
// clearSerialBuffer() - svuota IL BUFFER DELLA SERIALE
// ****************************************************************************************
void clearSerialBuffer() {
  char c;
  while (Serial.available() > 0) {
    c = Serial.read();
    delayMicroseconds(10000);
  }
}

// ****************************************************************************************
// testConnessione() - VERIFICA LA PRESENZA DELLA CONNESSIONE A INTERNET
// ****************************************************************************************
bool testConnessione() {
  ESP.wdtFeed();                                          // alimento HW WDT
  while (myBot.testConnection() == false) {
    lampeggia(5);                                         // lampeggia n volte e ritenta
  }
  while(ESP.getFreeHeap() < 45000) { // segnala se la ram scende sotto una determinata soglia
    lampeggia(10);
    // ESP.reset();
  }
  return true;
}

// ****************************************************************************************
// lampeggia() - IL LED ESP8266 LAMPEGGIA n VOLTE
// ****************************************************************************************
void lampeggia(byte lampi) {
  for (int ciclo = 1; ciclo <= lampi; ciclo++) {
    digitalWrite(LED, LOW);
    delayMicroseconds(50000);
    digitalWrite(LED, HIGH);
    delayMicroseconds(50000);
  }
}

// ****************************************************************************************
// help() - INVIA AL MITTENTE LA LISTA DEI COMANDI
// ****************************************************************************************
void help(uint32_t utente) {
  String hlp  = "/info  Stato dell'impianto\n";
         hlp += "/accendi  Accende la caldaia\n";
         hlp += "/spegni  Spegne la caldaia\n";
         hlp += "/tem  [99.9] Set Comfort\n";
         hlp += "/ledon  Accende il display\n";
         hlp += "/ledoff  Spegne il display\n";
         hlp += "/ora  [aaaa-mm-gg hh:mm:ss]\n";
  myBot.sendMessage(utente, hlp);                       // notifica i comandi al mittente
}

funziona tutto perfettamente finchè faccio prove e modifiche fino a notte inoltrata ma la mattina successiva esp8266 sembra morto, non risponde più.
eppure utilizzo il HW WDT che funziona benissimo in caso di disconnessione da WiFi o da mancanza temporanea di internet.
Ho terminato le mie modestissime risorse e quindi chiedo aiuto a voi.
vi ringrazio.

auguri anche a te

devo dire che la libreria che usi non la conosco, ma sono andato a vedermela e come praticamnte tutte usa pesantemente la classe String
e questo è un male, definitivamente, per tutte le MCU come Arduino

io circa 18 mesi fa ho stroncato completamente la libreria che usavo e mi sono scritto un insieme di funzioni in C per sostituirla

scopo: esattamente un cronotermo per arduino
se segui l'insieme delle mie discussioni aperte trovi
Libreria telegram
riconoscimento utenti
salvataggio e recupero variabili (password/settaggi)
riconoscimento generico di stringhe (comandi)
esecuzione di differenti funzioni a seconda di differenti indici (puntatori a funzione)

il tutto, una volta unito e condito con le solite cose (dichiarazioni, uscite, schede relè etc etc) porta esattamente a un cronootermostato su arduino con interfaccia su telegram (io non ho nemmeno display, faccio tutto da telegram)

facevo, adesso sono termocentralizzato, e sto "vendendo" la mia vecchia installazione a quello che ra il mio precedente vicino di casa......

Ti ringrazio per la risposta;
cerco la tua discussione, ma intanto volevo chiederti, ammesso che dipenda dalla memoria a causa delle stringhe perchè non entra in funzione il HW WDT???

L'argomento interessa anche me
Ma non saprei come fare, seguo con interesse

Ho iniziato a fare delle prove con il file include telegrambot.h di @standardoil e questo è il mio codice:

#include "telegrambot.h"

bool connesso = false;

void setup()
{
  delay(1000);
  Serial.begin(9600);
  pinMode(LED, OUTPUT);
  WiFi.mode(WIFI_STA);
  WiFi.begin("########", "########");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(500);
  }
  Serial.println(" ");
  connesso = true;
  Serial.println("*** CONNESSO ***");
  delay(500);
  


}

void loop()
{
  botread(); // lancio la ricezione
  // controllo che sia arrivato un nuovo messaggio

  if (appoggio > ultimo)
  {
    // ricevuto
    // aggiorno l'ultimo messaggio ricevuto
    ultimo = appoggio;
    Serial.println("+++ OK +++");
  }
  else
  {
    // non ricevuto
    Serial.println("--- KO ---");
  }
  delay(1000);
}

Ma sembra che telegrambot.connect(telegram, PORTA) in botread() risulti sempre falso anche se invio un messaggio dal bot, (ho messo un Serial.print("*** connesso ***"); all’interno ma non viene mai stampato.
Questo è il codice (escluse le funzioni per brevità) inserito in telegrambot.h

#include <EEPROM.h>
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>

// indirizzo del server e sua porta
IPAddress telegram(149, 154, 167, 198); // ho fatto un NSlookup
#define PORTA 443

// istanza del client
WiFiClientSecure telegrambot;

void botclose(int a = 0);   // protoripo della botclose, che ha argomento di default
unsigned long int ultimo;   // il numero dell'ultimo messaggio ricevuto
unsigned long int appoggio; // una variabile di appoggio
unsigned long int mittente; // il numero del mittente ultimo messaggio
unsigned long int io;       // tutti gli account di Telegram sono interi a 32 bit senza segno
#define LENTEXT 100
#define LED 2               // il led di trasmissione
char testo[LENTEXT];        // il testo appena ricevuto, massimo LENTEXT caratteri
byte lentext = 0;           // la lunghezza del testo trovato
char token[] = "qui ho messo il mio token"; // scrivere qui il token

se digito da browser l’URL di richiesta, ricevo correttamente come risposta tutti i messaggi di telegram in coda
di sicuro ho dimenticato qualcosa
…un piccolo aiutino per poter proseguire

Ok, vediamo di fare un po' di ordine:

la mia libreria non espone gli stessi metodi delle altre, non ne è una copia, ma una nuova soluzione
in effetti non espone alcun metodo, non è roba C++, ma santoC
cambia il modo di approcciarsi a telegram, proprio per non usare C++ e stringhe, ma restare terra terra
non ti posso garantire che vada con gli ESP8266-01 che usi tu, mai avuti, ma provare non costa nulla
se mi metto qui a spiegarti per filo e per segno come usarla non ne usciamo più, ma ho alternativa
poco tempo ne ho tratto un'applicazione semplificata per un mio amico, che vuole solo accendere /spegnere la sua caldaia, e gli ho "venduto" il mio vecchio Hardware
sono sicuro che funziona e che è abbastanza "corta" da poter essere ben commentata
adesso la riprendo, cancello password e similia e ne controllo e rileggo i commenti così sono sicuro siano comprensibili
abbi pazienza che tra poco la posto
anche per il LiberoMercante, vedi se ti può essere di indicazione

cambiando discorso, per lo OP:
come è poi andata a finire con quegli LM355z?

Il liberomercante sono io?

finalmente ti sei ricordato, in precedenza ero il segretario del sindaco - grazie

sto facendo qualche prova, ma non abbiamo una nodemcu

cioè, dovremmo averla, ma non la troviamo

amedeodivito:
Ma sembra che telegrambot.connect(telegram, PORTA) in botread() risulti sempre falso anche se invio un messaggio dal bot, (ho messo un Serial.print("*** connesso ***"); all'interno ma non viene mai stampato.
Questo è il codice (escluse le funzioni per brevità) inserito in telegrambot.h

se digito da browser l'URL di richiesta, ricevo correttamente come risposta tutti i messaggi di telegram in coda
di sicuro ho dimenticato qualcosa
..un piccolo aiutino per poter proseguire

e se invece provi a spedire?
anche in quel caso non va?
siccome mi ricordo che spedire è incredibilmente meno complicato che ricevere, magari prova solo a spedire, per cominciare

ok adesso ci provo.
comunque nel frattempo ho provato con un nodemcu esp12e e il risultato è identico.

Standardoil:
cambiando discorso, per lo OP:
come è poi andata a finire con quegli LM355z?

se ti riferisci a me ti dico che non funzionavano proprio, li ho riacquistati da un fornitore migliore e funzionano a meraviglia.
mia suocera diceva ....tanto pagare, tanto valere.

Rieccomi
allora ho inserito nel loop botsend(miaID, "Hello world!!!") e il risultato è stato;

.............
*** CONNESSO ***
Errore trasmissione telegram
Errore apertura bot

dove
...........
*** CONNESSO ***
si riferisce alla connessione wifi nel setup

p.s.
ho provato anche a dare per scontato di essere connesso togliendo la
if (telegrambot.connect(telegram, PORTA)) in botopen()
ma non trasmette nulla

questo funziona di certo
è l’ultima versione che uso io
rispetto a quella pubblicata nel 2018 ho cambiato qualche minuzia e riscritto un po’ meglio il tutto

programma: quello specifico per quel mio amico che vuole solo accendere la caldaia

// Nelson StandardOil
// per non dimenticare i gravi disastri petroliferi
// progetto "Metula"
// Petroliera - Stretto di Magellano - 9 agosto 1974 - 51.000 tonnellate
// un telegrambot per accendere spegnere una caldaia
// VZZ Versione senza password, e molto commentata, da dare come esempio




#define PROGETTO "Mt Metula"
#define VERSIONE "ZZ-esempio Zibellino Zootecnico" // Versione commentata da postare come esempio

// variabili globali e librerie

// generiche
#include <nelson.h>
#include <ESP8266WiFi.h>
#include "new-wifi-connect.h"
char ssid[] = "XXXXXXXXXX";
char password[] = "XXXXXXXXXXX";

// telegram
char token[] = "XXXXXXXXX:XXXXXXXXXXXXXXXXXXXXXXXXX";
// prima della include che lo usa
#include "newtelegrambot.h"

unsigned long int utente = 0; // l'unico utente autorizzato
unsigned long int ultimaazione; // tempo di quando è stata eseguita l'ultima azione
unsigned long int passo = 1; // tempo da attendere tra una interrogazione Telegram e la successiva


//per il termometro
// classica applicazione delle termosonde DS18B20
#include <OneWire.h>
#include <DallasTemperature.h>
float temperatura;
#define ONE_WIRE_BUS D4 // DS18B20 pin
// D0 non va, chissa come mai
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature DS18B20(&oneWire);


void setup()
{
    Serial.begin(9600);
    pinMode(D5, OUTPUT);// primo relè
    pinMode(D6, OUTPUT);// secondo relè

    // su il wifi
    if (!collegaalwifi(ssid, password))
        // collegalawifi è una funzione che esegue la connessione (ovvio, vero?) si trova nella newwificonnect
    {
        Serial.println("Errata connessione al wi-fi");
        // mancata connessione
    }

    Serial.println();
    Serial.println("Maggiordomo Automatico");
    Serial.println(PROGETTO);
    Serial.print("Versione: ");
    Serial.println(VERSIONE);
    Serial.print("Connesso: IP: ");
    Serial.println(WiFi.localIP());
    botopen(utente); // botopen(unsigned long int numero dell'utente) inizia un messaggio Telegram verso utente
    telegrambot.print(PROGETTO);
    telegrambot.print(F(" avviato.%0AVersione: ")); // %0A è il ritorno a capo, usare un println() chiuderebbe il messaggio
    telegrambot.print(VERSIONE);
    botclose(); // chiude il messaggio e ne provoca l'inoltro
    botread(); // una (serie di) botread() a vuoto svuotano l'eventuale coda di messaggi in ingresso che non sono ancora stati ricevuti, emessi prima dell'accensione

    while (appoggio > ultimo)
    // appoggio e ultimo sono rispettivamente il numero identificativo dell'ultimo messaggio ricevuto e correttamente trattano e dell'ultimo messaggio ricevuto
    {
        ultimo = appoggio;
        botsend(utente, "Eliminato messaggio in coda"); // la funzione botsend è la sorella minore delle botopen-botclose, fa tutto in una sola riga, ma non può andare a capo o costruire messaggio complessi
        botsend(utente, testo);
        botread();
    }
}



void loop()
{
    // quando è passato il tempo tre una lettura e la successiva (per risparmiare traffico internet)
    if (millis() - ultimaazione > passo * 1000UL)
    {
        {
            // solo se siamo connessi
            if (WiFi.status() == WL_CONNECTED)
            {
                ultimaazione = millis();
                aggiorna();// aggiorna per leggere se ho un messaggio da telegram
                // la aggiorna() legge ed esegute il prossimo messaggio in arrivo da Telegram
                // solo uno,
                // naturalmente se non ci sono messaggi da ricevere non fa nulla
            }
            else
            {
                // non siamo connessi
                // per questo turno non leggo telegram
                // ma tento la riconnessione
                Serial.println(F("Connessione wi-fi assente"));
                delay(1000);
                passo = 60; //per non farlo troppo spesso
                collegaalwifi(ssid, password);
            }

            passo++;

            if (passo > 60)
            {
                passo = 60;
            }
            
        }
    }
}


void aggiorna(void)
{
    botread(); // lancio la ricezione
    // controllo che sia arrivato un nuovo messaggio
    // la botread() legge l'eventuale primo messaggio in coda di ricezione
    // se lo trova aggiorna la variabile "ultimo", che pertanto sarà maggiore della "appoggio"
    // sempre se lo trova aggiorna tutte le variabili globali dove registra "mittente" e "testo"

    if (appoggio > ultimo)
    {
        // aggiorno l'ultimo messaggio ricevuto
        ultimo = appoggio;
        passo = 1;
// e poi costruisco la risposta
// usando botopen e botclose, per poter costruire una risposta "complessa" senza dover usare gli oggetti String
        // se il mittente è autorizzato:
        if (mittente == utente)
        {
            Serial.print("Messaggio ricevuto: ");
            Serial.print(testo);
            Serial.println();
            botopen(utente);
            telegrambot.print("Ricevuto comando: ");
            telegrambot.print(testo);

            if (!strlen(testo))
            {
                telegrambot.print("Attenzione: testo assente");
            }

            botclose();

            if (strlen(testo))
            {
                // adesso devo trattare il testo:
                tratta(testo);
                // naturalmente la tratta() riceve una stringa di C e ne riconosce i comandi da eseguire
            }
        }
        else
        {
            // utente non autorizzato
            Serial.println("Messaggio ricevuto da utente non autorizzato");
            Serial.print("Utente: ");
            Serial.println(mittente);
            Serial.print("Messaggio: ");
            Serial.print(testo);
            Serial.println();
        }
    }
}



void tratta(char * testo)
{
    static bool rele1 = 0;
    static bool rele2 = 0;

    if (uguale(testo, "accendi"))
    // la funzione uguale(char *, char*) è banalmente una wrapper della strcmp(), ma mi viene comoda usarla così
    // inoltre è definita nella  ia libreria nelson.h, ma basta farla come:
    // #define uguale(a,b) !strcmp(a, b)
    {
        rele1 = 1;
        digitalWrite(D5, rele1);
        botsend(utente, "Caldaia accesa");
        return;
    }

    if (uguale(testo, "spegni"))
    {
        rele1 = 0;
        digitalWrite(D5, rele1);
        botsend(utente, "Caldaia spenta");
        return;
    }

    if (uguale(testo, "stato"))
    {
        DS18B20.requestTemperatures();
        delay(750);
        temperatura = DS18B20.getTempCByIndex(0);
        botopen(utente);
        telegrambot.print("Stato della caldaia: ");

        if (rele1)
        {
            telegrambot.print("accesa");
        }
        else
        {
            telegrambot.print("spenta");
        }

        telegrambot.print("%0ATemperatura attuale: ");
        telegrambot.print(temperatura);
        botclose();
        return;
    }

    botopen(utente);
    telegrambot.print("Comando sconosciuto");
    telegrambot.print("%0AComandi accettati:");
    telegrambot.print("%0Aaccendi -> accende la caldaia");
    telegrambot.print("%0Aspegni -> spegne la caldaia");
    telegrambot.print("%0Astato -> caldaia accesa Si/No");
    botclose();
}

poi ti metto le tre librerie che uso io

nelson.h
newtelegrambot.h
new-wifi-connect.h

che sono le versioni aggiornate di quelle storiche

nelson.h (8.37 KB)

newtelegrambot.h (8.67 KB)

new-wifi-connect.h (530 Bytes)

Ti ringrazio per la disponibilità.
mi metto subito all'opera e ti faccio sapere.

Eccomi di nuovo.
Ho provato il tuo sketch eliminando solo le parti relative ai sensori e i pin dei relè che io gestisco con altra MCU via seriale.
Ebbene purtroppo il risultato è lo stesso di prima:

amedeodivito:
..............
Maggiordomo Automatico
Mt Metula
Versione: ZZ-esempio Zibellino Zootecnico
Connesso: IP: 192.168.43.241
Mancata connessione in trasmissione

Visto che in questi giorni Telegram è stato aggiornato ho pensato a qualche modifica ma non è cosi
ho caricato il mio sketch con la libreria CTBot.h e tutto funziona (anche se per poche ore) ho visto anche che per verificare la connessione, CTBot utilizza un metodo simile al tuo (telegrambot.connect(telegram, PORTA).

prova a cercare il bot CronoTermo (@mioesp8266_bot) e prova, anche se funziona solo /help

Boh, non capisco
Ho controllato personalmente prima di postare, e dopo postato ho riscritto le password e ricontrollato
Sono sicuro che funziona
Posta il programma che vediamo

Ti credo, sono confuso e dispiaciuto, non vorrei disturbare oltre.
ti invio lo sketch.

// Nelson StandardOil
// per non dimenticare i gravi disastri petroliferi
// progetto "Metula"
// Petroliera - Stretto di Magellano - 9 agosto 1974 - 51.000 tonnellate
// un telegrambot per accendere spegnere una caldaia
// VZZ Versione senza password, e molto commentata, da dare come esempio




#define PROGETTO "Mt Metula"
#define VERSIONE "ZZ-esempio Zibellino Zootecnico" // Versione commentata da postare come esempio

// variabili globali e librerie

// generiche
#include "nelson.h"
#include <ESP8266WiFi.h>
#include "new-wifi-connect.h"
char ssid[] = "##########";
char password[] = "##########";

// telegram
char token[] = "###############################################";
// prima della include che lo usa
#include "newtelegrambot.h"

uint32_t          utente = #########; // l'unico utente autorizzato
unsigned long int ultimaazione;       // tempo di quando è stata eseguita l'ultima azione
unsigned long int passo = 1;          // tempo da attendere tra una interrogazione Telegram e la successiva


//per il termometro
// classica applicazione delle termosonde DS18B20
// #include <OneWire.h>
// #include <DallasTemperature.h>
// float temperatura;
// #define ONE_WIRE_BUS D4 // DS18B20 pin
// D0 non va, chissa come mai
// OneWire oneWire(ONE_WIRE_BUS);
// DallasTemperature DS18B20(&oneWire);


void setup()
{
    Serial.begin(9600);
//    pinMode(D5, OUTPUT);// primo relè
//    pinMode(D6, OUTPUT);// secondo relè

    // su il wifi
    if (!collegaalwifi(ssid, password))
        // collegalawifi è una funzione che esegue la connessione (ovvio, vero?) si trova nella newwificonnect
    {
        Serial.println("Errata connessione al wi-fi");
        // mancata connessione
    }

    Serial.println();
    Serial.println("Maggiordomo Automatico");
    Serial.println(PROGETTO);
    Serial.print("Versione: ");
    Serial.println(VERSIONE);
    Serial.print("Connesso: IP: ");
    Serial.println(WiFi.localIP());
    botopen(utente); // botopen(unsigned long int numero dell'utente) inizia un messaggio Telegram verso utente
    telegrambot.print(PROGETTO);
    telegrambot.print(F(" avviato.%0AVersione: ")); // %0A è il ritorno a capo, usare un println() chiuderebbe il messaggio
    telegrambot.print(VERSIONE);
    botclose(); // chiude il messaggio e ne provoca l'inoltro
    botread(); // una (serie di) botread() a vuoto svuotano l'eventuale coda di messaggi in ingresso che non sono ancora stati ricevuti, emessi prima dell'accensione

    while (appoggio > ultimo)
    // appoggio e ultimo sono rispettivamente il numero identificativo dell'ultimo messaggio ricevuto e correttamente trattano e dell'ultimo messaggio ricevuto
    {
        ultimo = appoggio;
        botsend(utente, "Eliminato messaggio in coda"); // la funzione botsend è la sorella minore delle botopen-botclose, fa tutto in una sola riga, ma non può andare a capo o costruire messaggio complessi
        botsend(utente, testo);
        botread();
    }
}



void loop()
{
    // quando è passato il tempo tre una lettura e la successiva (per risparmiare traffico internet)
    if (millis() - ultimaazione > passo * 1000UL)
    {
        {
            // solo se siamo connessi
            if (WiFi.status() == WL_CONNECTED)
            {
                ultimaazione = millis();
                aggiorna();// aggiorna per leggere se ho un messaggio da telegram
                // la aggiorna() legge ed esegute il prossimo messaggio in arrivo da Telegram
                // solo uno,
                // naturalmente se non ci sono messaggi da ricevere non fa nulla
            }
            else
            {
                // non siamo connessi
                // per questo turno non leggo telegram
                // ma tento la riconnessione
                Serial.println(F("Connessione wi-fi assente"));
                delay(1000);
                passo = 60; //per non farlo troppo spesso
                collegaalwifi(ssid, password);
            }

            passo++;

            if (passo > 60)
            {
                passo = 60;
            }
           
        }
    }
}


void aggiorna(void)
{
    botread(); // lancio la ricezione
    // controllo che sia arrivato un nuovo messaggio
    // la botread() legge l'eventuale primo messaggio in coda di ricezione
    // se lo trova aggiorna la variabile "ultimo", che pertanto sarà maggiore della "appoggio"
    // sempre se lo trova aggiorna tutte le variabili globali dove registra "mittente" e "testo"

    if (appoggio > ultimo)
    {
        // aggiorno l'ultimo messaggio ricevuto
        ultimo = appoggio;
        passo = 1;
// e poi costruisco la risposta
// usando botopen e botclose, per poter costruire una risposta "complessa" senza dover usare gli oggetti String
        // se il mittente è autorizzato:
        if (mittente == utente)
        {
            Serial.print("Messaggio ricevuto: ");
            Serial.print(testo);
            Serial.println();
            botopen(utente);
            telegrambot.print("Ricevuto comando: ");
            telegrambot.print(testo);

            if (!strlen(testo))
            {
                telegrambot.print("Attenzione: testo assente");
            }

            botclose();

            if (strlen(testo))
            {
                // adesso devo trattare il testo:
                tratta(testo);
                // naturalmente la tratta() riceve una stringa di C e ne riconosce i comandi da eseguire
            }
        }
        else
        {
            // utente non autorizzato
            Serial.println("Messaggio ricevuto da utente non autorizzato");
            Serial.print("Utente: ");
            Serial.println(mittente);
            Serial.print("Messaggio: ");
            Serial.print(testo);
            Serial.println();
        }
    }
}



void tratta(char * testo)
{
    static bool rele1 = 0;
    static bool rele2 = 0;

    if (uguale(testo, "accendi"))
    // la funzione uguale(char *, char*) è banalmente una wrapper della strcmp(), ma mi viene comoda usarla così
    // inoltre è definita nella  ia libreria nelson.h, ma basta farla come:
    // #define uguale(a,b) !strcmp(a, b)
    {
        rele1 = 1;
//        digitalWrite(D5, rele1);
        botsend(utente, "Caldaia accesa");
        return;
    }

    if (uguale(testo, "spegni"))
    {
        rele1 = 0;
//        digitalWrite(D5, rele1);
        botsend(utente, "Caldaia spenta");
        return;
    }

//    if (uguale(testo, "stato"))
//    {
//        DS18B20.requestTemperatures();
//        delay(750);
//        temperatura = DS18B20.getTempCByIndex(0);
//        botopen(utente);
//        telegrambot.print("Stato della caldaia: ");
//
//        if (rele1)
//        {
//            telegrambot.print("accesa");
//        }
//        else
//        {
//            telegrambot.print("spenta");
//        }
//
//        telegrambot.print("%0ATemperatura attuale: ");
//        telegrambot.print(temperatura);
//        botclose();
//        return;
//    }

    botopen(utente);
    telegrambot.print("Comando sconosciuto");
    telegrambot.print("%0AComandi accettati:");
    telegrambot.print("%0Aaccendi -> accende la caldaia");
    telegrambot.print("%0Aspegni -> spegne la caldaia");
    telegrambot.print("%0Astato -> caldaia accesa Si/No");
    botclose();
}

io riprovo sul nodemcu esp12

Nessun disturbo, tranquillo,è un piacere

Però guardò e riguardo e non capisco

Te pensa che il messaggio di errore "mancata connessione in trasmissione" non lo ho mai ricevuto

Non mi ha mai perso un colpo...

Ci penso stanotte

abbamo provato anche noi, con il programma di @amedeo
ide 1.8.10 non va, mancata connessione in trasmissione, confermiamo

BTW anche a me fa la storia di trovare più di una libreria che invece so essere singola

naturalmente abbiamo importato e messo nel path le tre librerie di @Standard

Devo purtroppo confermare

anche a me, con la 1.8.10 su ubuntu 18.04 x64 fa "mancata connessione in trasmissione"

sullo stesso sistema operativo IDE1.8.5, lo stesso programma con le stesse 3 librerie "private" funziona regolarmente

provo a vederci dentro.......

C'è qualcosa di sbagliato nell'IDE 1.8.10

non è solo che trova doppie librerie ma anche che NON usa le librerie corrette
mi spiego:
ho cambiato la scritta d'errrore nella mia newtelegrambot da "mancata connessione in trasmissione" a "Mancata Connessione in Trasmissione"
invece nella installazione 1.8.5 ho scritto "Trasmissione mancata, nessuna connessione"

inoltre ho cambiato la scritta di versione da
"#define VERSIONE "ZZ-esempio Zibellino Zootecnico" // Versione commentata da postare come esempio"
a
"#define VERSIONE "ZZ-esempio Zibellino ZOOtecnico" // Versione commentata da postare come esempio"

guardate cosa mi esce nel monitor seriale, dopo aver compilato e trasferito

Connessione al wifi: xxxxxxxxxxxxxxx
......
Maggiordomo Automatico
Mt Metula
Versione: ZZ-esempio Zibellino ZOOtecnico
Connesso: IP: 192.168.1.69
Mancata connessione in trasmissione

Mescolando scritte prese chissa' da dove, e che non ci sono nei sorgenti,
boh, ci penso ancora, ma per me squadra che vince non si cambia, tengo la 1.8.5.......

come volevasi dimostrare, tornato sulla 1.8.5 funziona tutto e la scritte sono congrue coi sorgenti da dove dovrebbero provenire

quindi per il momento mi fermo, non ho soluzione se non dire: compila su 1.8.5, li va