Thingspeak avec esp32

Bonjour,
j'ai réalisé ce petit test pour apprendre à utiliser thiingspeak.
Je n'arrive pas à visualiser mes valeurs, pas d'erreur affiché dans la console arduino et j'ai bien l'affichage dans ma console des données qui sont envoyé.
image
image

Voici mon programme :


#include <Wire.h>

#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>



#define SEALEVELPRESSURE_HPA (1013.25)

Adafruit_BME280 bme; // I2C
//Adafruit_BME280 bme(BME_CS); // hardware SPI
//Adafruit_BME280 bme(BME_CS, BME_MOSI, BME_MISO, BME_SCK); // software SPI

unsigned long delayTime;


//paramètre du WIFI
#include <WiFi.h>

String apiKey = "API-key"; 
const char* ssid = "ID_BOX"; // à changer pour chaque nouveau réseau Wifi
const char* pass = "mdp_box"; // à changer pour chaque nouveau réseau Wifi
const char* server = "api.thingspeak.com";
WiFiClient client;




void setup() {
    Serial.begin(115200);
    
    //Initialisation du WIFI
 Serial.println("Connecting to ");
       Serial.println(ssid);
 
 
       WiFi.begin(ssid, pass);
 
      while (WiFi.status() != WL_CONNECTED) 
     {
            delay(500);
            Serial.print(".");
     }
      Serial.println("");
      Serial.println("WiFi connected");
    
  
    while(!Serial);    // time to get serial running
    Serial.println(F("BME280 test"));

    unsigned status;
    
    // default settings
    status = bme.begin();  
    // You can also pass in a Wire library object like &Wire2
    // status = bme.begin(0x76, &Wire2)
    if (!status) {
        Serial.println("Could not find a valid BME280 sensor, check wiring, address, sensor ID!");
        Serial.print("SensorID was: 0x"); Serial.println(bme.sensorID(),16);
        Serial.print("        ID of 0x60 represents a BME 280.\n");

        while (1) delay(10);
    }
    
    Serial.println("-- Default Test --");
    delayTime = 1000;

    Serial.println();
}


void loop() { 


    float h = bme.readHumidity();
    float t = bme.readTemperature();

     if (isnan(h) || isnan(t)) 
                 {
                     Serial.println("Failed to read from bme sensor!");
                      return;
                 }
    if (client.connect(server,80))   //   
                      {  
                            
                             String postStr = apiKey;
                             postStr +="&field1=";
                             postStr += String(t);
                             postStr +="&field2=";
                             postStr += String(h);
                             postStr += "\r\n\r\n";
 
                             client.print("POST /update HTTP/1.1\n");
                             client.print("Host: api.thingspeak.com\n");
                             client.print("Connection: close\n");
                             client.print("X-THINGSPEAKAPIKEY: "+apiKey+"\n");
                             client.print("Content-Type: application/x-www-form-urlencoded\n");
                             client.print("Content-Length: ");
                             client.print(postStr.length());
                             client.print("\n\n");
                             client.print(postStr);
 
                             Serial.print("Temperature: ");
                             Serial.print(t);
                             Serial.print(" degrees Celcius, Humidity: ");
                             Serial.print(h);
                             Serial.println("%. Send to Thingspeak.");
                        }
          client.stop();
 
          Serial.println("Waiting...");
  
  // thingspeak needs minimum 15 sec delay between updates
  delay(1000);
}
  



void printValues() {
    Serial.print("Temperature = ");
    Serial.print(bme.readTemperature());
    Serial.println(" °C");

    Serial.print("Pressure = ");

    Serial.print(bme.readPressure() / 100.0F);
    Serial.println(" hPa");

    Serial.print("Approx. Altitude = ");
    Serial.print(bme.readAltitude(SEALEVELPRESSURE_HPA));
    Serial.println(" m");

    Serial.print("Humidity = ");
    Serial.print(bme.readHumidity());
    Serial.println(" %");

    Serial.println();
}

Bonjour

 // thingspeak needs minimum 15 sec delay between updates

Comment est assuré l'intervalle de temps de 15 secondes mini entre deux envois vers ThingSpeak ?
(version gratuite)

En cas de non respect de cet intervalle ThingSpeak peut ignorer les données !

Pour information : ThingSpeak prpose une librairie Arduino elle simplifie les choses
On peut la voir à l'oeuvre dans ce tutoriel : https://randomnerdtutorials.com/esp32-thingspeak-publish-arduino/

Ok merci , je vais essayer avec la librairie, les 15 secondes je dois mettre un delay de 15s ? (j'ai essayé et ça ne fonctionne pas ) ou c'est dans les paramètre thingspeak ?

L'intervalle d'au moins 15s est à réa dans le code , soit par delay() soit par l'utilisation de millis, soit dans mon cas par la durée de mise en sommeil profond (deep-sleep).

Sans librairie ThingSpeak j'ai plutôt fait des requêtes GET dans ce style :

  // connection TCP au serveur désignée par 'host','port'
  WiFiClient client;

  if (!client.connect(host, port)) {
    Serial.println("erreur de connection");
    Serial.println("attente x sec...");
    delay(10);
  }

  // préparer la requete GET à ThingSpeak
  String url = "/update?key=";
  url += thingspeak_key;
  url += "&field1=";
  url += String(vbatt);
  url += "&field2=";
  url += String(temp_celsius);
  url += "&field3=";
  url += String(duree); // envoi dure session complète précédente (@ramRTC)

  // envoyer requete GET au serveur
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + host + "\r\n" +
               "Connection: close\r\n\r\n");

  //lire la réponse ThingSpeak
  String line = client.readStringUntil('\r');
  client.println(line);

  Serial.println("fermeture de la  connection");
  client.stop();

ok super j'ai réussi comme ceci.

if (!client.connect(server, 80)) {
    Serial.println("erreur de connection");
    Serial.println("attente x sec...");
    delay(10);
    //return;
  }

  // préparer la requete GET à ThingSpeak
  String url = "/update?key=";
  url += thingspeak_key;
  url += "&field1=";
  url += String(h);
  url += "&field2=";
  url += String(t);
 

  // envoyer requete GET au serveur
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + server + "\r\n" +
               "Connection: close\r\n\r\n");

  //lire la réponse ThingSpeak
  String line = client.readStringUntil('\r');
  client.println(line);

  Serial.println("fermeture de la  connection");
  client.stop();
  
  delay(15000);
}

ça convient ou pas....goûts et couleurs.....contraintes, priorités....

Pour ma part j'ai divers capteurs connectés envoyant par WiFi leurs données vers ThingSpeak
J'ai aussi des capteurs LoRaWAN dont les données, via le résau collaboratif TTN , aboutissent sur ThingSpeak

En version gratuite 32 courbes : 4 écrans ("channels") de 8 courbes ("fields") + des graphes résultant d'un traitrement statistique ou autre sur les données envoyées (petit temps de calcul Matlab offert)

Les capteurs sonr réduits à la plus simple expression autour d'une carte ESP8266 ou ESP32 minimale passant le plus clair de son temps en sommeil profond. Autonomie 6 à 9 mois selon les capteurs et l'intervalle entre deux réveils

pour la consultation j'utilise au quotidien l'appli Android ThingsViewFull
L'écran des capteurs est donc .....celui du smartphone.....

Avenir : Mathworks/Matlab qui a maintenant a ThingSpeak dans son giron, semble vouloir maintenir une version gratuite ... dommage qu'ils ne fassent de même pour Matlab.....

Après avoit testé d'autres solutions locales sur Raspberry Pi comme ThingsBoard ou InfluxdB+Grafana j'ai tendance à revenir au bout d'un certain à ThingSpeak qui pour moi fait très bien l'affaire pour héberger, présenter et traiter mes données.

Mon seul regret : l'absence d'effort de la part de ThingSpeak pour faciliter (actualiser) l'installation locale de son serveur, Open source en théorie mais au vu des dépendances multiples très difficile à installer correctement (+pas encore trouvé de version Docker réellement utilisable)

1 Like

Ducoup par exemple avec ce système je peux mettre mon esp32 en deep-sleep pendant 5 min, le réveiller, prendre les mesures, retourner en deep- sleep et il ne consommera quasiment rien.

Exactement !

En deep-sleep la consommation sera celle de la puce ESP32 (5µA valeur typique) + celle des autres composants du montage (régulateur, unterface USB, capteurs ......

En deep_sleep je peux encore piloter mes leds ?
par exemple si il fait 20 °C laisser la led verte allumé jusqu'a la prochaine prise de mesure

ça paraït possible à condition d'étudier de près le comportement particulier de certains GPIOs durant le deep-sleep ('GPIO s RTC' dans le jargon d'Espressif) , comportement différent de celui du fonctionnement normal.
j'ai vu des choses das ce sens mais n'ai pas sous la main la réponse à la question du maintien d'un état logique de sortie pendant le deep-sleep.

le problème avec tes récentes interventions c'est l'ajout des données du 'cahier des charges' au goutte à goutte... :unamused:
*Si tu mettais ur la table l'intégralité du cahier de charges il serait plus facile de répondre de manière pertinenteh

C'est au goutte à goutte car mon projet n'est pas encore définit entièrement, je test un peu tout ce qui est possible et pas possible :slight_smile: pour essayer de sortir un bon truc.
Je viens ducoup de test mon programme , 105 ma en deep-sleep au réveil : 140 - 150 puis un pic à 200 puis retour 140 - 150 puis 105 ma .
105 ma en deep-sleep ça parait élevé ? 5 catpeurs (3 leds 20 mA branché mais je ne les allume pas )

Au niveau de thingspeak, on peut garder les données de combien de temps ? avec l'outil export recent data ?

"Export recent data" pas testé mais "Export" vient de fournir un fichier CSV avec toutes les données d'un canal depuis mars 2017 !! Pas de dates à fournir , il montre la totale( = 'tous les 'fields' d'un 'channel' donné)
Export

Il me semble que ThingSpeak gratuit est bridé en volume annuel ,voir la license et en cadence (> 15s)

Ok merci , ducoup mes valeurs de conso ne choc pas ? je viens de refaire mes tests , un panneau 10 w et une batterie 10 A suffiront, normalement 5w suffiront et 9.5 A si je met un panneau 10 w ma batterie sera plus vite rechargé ? est 'il mieux d'augmenter le panneau solaire ou l'ampérage de la batterie ?

La discussion maintenant aurait sa place dans l'autre fil en mentionnant une donnêe nouvelle de consommation, on quitte le sujet ThingSpeak.

Avant de choisir batterie et panneau tu pourrais peut être tenter de reduire le courant quand l'ESP32 est en deep-sleep....
Où vont les 100 mA ?
C'est le cumul des capteurs ?
Si oui est il nécessaire de les maintenir tous alimentés en permanence ?
Certains nécessitent-ils un préchauffage ?

ok je vais regarder à ça

Cette méthode est souvent génératrice d'usines à gaz mal foutues.
Il est de loin préférable de définir clairement son besoin, de trouver l'architecture qui couvrira au mieux ce besoin et de s'y tenir.
De plus les petits micro Atmel ou ESP étant assez bon marché, il est plus simple de fractionner les besoins en autant de sous-ensembles dédiés
Sinon, très vite on accouche d'une lettre au père Noël pour un truc qui doit suivre l'évolution de la météo, surveiller la consommation de la maison, commander les lumières, superviser la serre au fond du jardin et faire le café.

Surtout que le sujet est parti de la manière suivante :

Avec ensuite un contournement en cherchant un écran basse-conso :

Si la bonne question avait été posée dès le départ :

Comment pourrais-je afficher les données de différents capteurs sur un écran, sachant que le montage sera autonome, alimenté par une batterie et un panneau solaire.

On n'en serait pas arrivé à ce stade, 80 réponses à l'heure actuelle, et pour presque rien.