esp32 TTGO Lora + ThingSpeak

Bonjour,

je m'évertue depuis plusieurs jours à transmettre des données à partir d'un module esp32 TTGO Lora vers ThingSpeak et ça ne veut rien savoir.

J'ai réduit le programme au minimum en reproduisant le sketch utilisé avec des esp8266 (qui fonctionnent parfaitement) sans succès.

j'ai remis à jour les bibliothèques bref, ma question est de savoir si l'un d'entre vous a déjà tenté un transfert sur ThingSpeak à partir de ces modules particuliers.

J'ajoute que le transfert via udp vers influxdb fonctionne en routine avec ces mêmes éléments.

Cordialement

je testerai prochainement avec cette même configuration

tu fait tes essais 'envoi vers ThingSpeak par HTTP GET , HTTP POST ou par MQTT ?
A quel niveau ça bloque ? au niveau de la collecte locale des données ou de la transmission vers ThingSpeak ?
Je pourrais tester ton code.

Je transmets avec HTTP POST.

Ça ne bloque pas, j’ai ajouté une ligne pour vérifier que la donnée RSSI passait bien donc tout semble correct mais je n’ai rien sur thingspeak. Je dois commettre une erreur quelque part sans doute.

Je te joins mon code que j’ai épuré (j’ai supprimé la lib lora) pour me rapprocher de la config esp8266).

#include <SPI.h>
#include <WiFi.h>
#include <Wire.h>
#include <ThingSpeak.h>

#define SS      18
#define RST     14
#define DI0     26
#define BAND    868E6

//Parametrage du WiFi, le mot de passe est la cle WIFI
const char* ssid = "xxxxxxx"; // Le nom de la box
const char* password = "xxxxxxx"; // Le mot de passe

WiFiClient client;

// Parametrages ThingSpeak
const int channelID = xxxx;
String writeAPIKey = "xxxxxx"; // ecrit API key pour votre canal ThingSpeak
const char* server = "api.thingspeak.com"; // Adresse du serveur ThingSpeak
const int mininterval = 3; // intervalle de temps en minutes, entre deux enregistrements
const int postingInterval = mininterval * 60000; // idem en millieme de seconde
int rssi ;

void setup() {
  Serial.begin(57600);
  delay(10);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
}
void loop() {
  delay(10);
  if (client.connect(server, 80)) {
    //Mesure la force du signal de la connexion WiFi (RSSI)
    long rssi = WiFi.RSSI();
    // Construit le corps de l'API (le contenu des menus)
    String body = "field1=";
    body += String(rssi);

    Serial.println("force du signal");// Pour vérifier que la donnée rssi est bien mesurée
    Serial.println(rssi);

    client.print("POST /update HTTP/1.1\n");
    client.print("Host: api.thingspeak.com\n");
    client.print("Connection: close\n");
    client.print("X-THINGSPEAKAPIKEY: " + writeAPIKey + "\n");
    client.print("Content-Type: application/x-www-form-urlencoded\n");
    client.print("Content-Length: ");
    client.print(body.length());
    client.print("\n\n");
    client.print(body);
    client.print("\n\n");
  }
  client.stop();
  delay(postingInterval);
}

merci d’avance

tuas regarder leur exemple sur github.??

Bonsoir

ma question est de savoir si l’un d’entre vous a déjà tenté un transfert sur ThingSpeak à partir de ces modules particuliers.

je viens de tester OK sur une carte “TTGO LoRa Oled V1” un code ESP32 (requètes HTTP GET ici)

Toutes les minutes Il lance une mesure sur le capteur hall interne d’un ESP32 et envoie le résultat à ThingSpeak puis passe en ‘deepsleep’
Pas de PB les données sont bien visibles s sur la page du canal ThingSpeak

La puce Lora SX1276 et l’afficheur Oled ne sont pas uilisé ici , le code ayant été fait auparavant pour unecarte ESP32 basique (Lolin 32)

/*
  test OK 
  
  ESP32 : TTGO LoRa OLED V1

  envoi capteur hall interne vers thingspeak 
*/

//****** parametres pour ThingSpeak****************
const uint16_t port = 80;
const char     * host = "api.thingspeak.com"; // ip or dns
unsigned long  myChannelNumber  = NUMERO DE CANAL;
const char     * thingspeak_key = "CLEF THINGSPEAK"; 


//****** parametres point d'accès WiFi**************
const char* ssid = "POINT D'ACCES";
const char* pass = "PASS";


//***** parametres deepSleep **********************
#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */
#define TIME_TO_SLEEP  60        /***************** DUREE DE SOMMEILen secondes **************/
#include "esp_deep_sleep.h" 

#include <WiFi.h>

int valHall; //capteur interne ESP32


void setup() {

  Serial.begin(115200);
  delay(100);

  esp_deep_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
  Serial.println("Sommeil programmé pour " + String(TIME_TO_SLEEP) + " Secondes");

  // connection au point d'accès, box...
  //WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS);
  WiFi.begin(ssid, pass);

  Serial.println();
  Serial.print("Attente WiFi... ");

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(100);
  }

  Serial.println("Addresse ip: ");
  Serial.println(WiFi.localIP());
  Serial.println();
  delay(100);

  // mesures
  valHall = hallRead();

  Serial.println(valHall);
  Serial.println(".....");

  Serial.print("connection à  ");
  Serial.println(host);

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

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

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


  // 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 de ThingSpeak
  String line = client.readStringUntil('\r');
  client.println(line);

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

  Serial.println("dodo.....");
  
  //********************************DODO !!!
  esp_deep_sleep_start();
}

void loop() {
}

Merci à vous deux,

Oui, j'ai regardé les exemples sur github et ailleurs mais je suis resté accroché à mon sketch fonctionnant sous esp8266...

Je vais reprendre l'exemple ci-dessus.

Mais je serais curieux de savoir si mon sketch tourne sur tes modules qui excepté l'oled semblent les mêmes.

Je viens de tester, ça fonctionne chez moi aussi.

A moi maintenant d'adapter à mon projet.

Merci encore

Bonjour,

j'ai pas mal ramé, en fait les problèmes venaient (semble-t-il) de la gestion des deux mécanismes : la réception des données LoRa et l'envoi des données à ThingSpeak. j'ai donc mis des temporisations entre les deux événements, plus d'autres petites choses.

J'ai repris mon vieux schéma avec l'utilisation de la boucle loop, l'exemple utilisait la fonction sleep dans le setup. Ça marchait mais je n'ai jamais pu actualiser mes données (pas trop insisté non plus...)

Donc tout marche, je teste encore avant de combiner avec un envoi via udp sur mon serveur local pour disposer à la fois d'un stockage dans le cloud ThingSpeak et localement.

Ah oui, j'oubliais, un des problèmes est vraiment l'antenne métallique WiFi, la connexion n'est pas systématique, je suis à 15 mètres de la box avec des murs de 60cm. Pour pallier ce problème j'ai utilisé un cpl/antenne/répéteur placé au voisinage de mon montage. Là, plus de problème.

Merci du coup de main.

un petit rajout :

j'ai ajouté la partie de code renvoyant simultanément sur mon serveur raspberry. Tout fonctionne.

mais ça reste en test