arduino esp 8266 esp-e/f

capteur dht11

a marqué ce sujet comme résolu.

bonjour . je suis tout nouveau sur votre forum .

à dire vrai , c’est mon tout premier post.

j’ai une question :

sur le esp 8266 , (arduino wifi) (esp-f utilisé avec les sources de l' esp-e , celles du geekcreit étant à ce jour , indisponnibles)

j’ai réussi à créer , de bric et de broc , un petit programme .

bon , je vais être honnête ,

je l’ai compilé en y ajoutant de bouts de code chipés à droite , à gauche .

le serveur n’est pas de ma composition sauf le paragraphe sur le dht11 .

j’ai pioché dans les exemples de l' I.D.E. sous linux debian .

donc , j’arrive à me servir du dht pour afficher la température et l’humidité … dans le moniteur série .

dans la page html , je sais pas faire ….

à titre indicatif , voilà le code :

/*
    This sketch demonstrates how to set up a simple HTTP-like server.
    The server will set a GPIO pin depending on the request
      http://server_ip/gpio/0 will set the GPIO2 low,
      http://server_ip/gpio/1 will set the GPIO2 high
    server_ip is the IP address of the ESP8266 module, will be
    printed to Serial when the module is connected.
*/

// librairies :
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <dht.h>

// initialisations :
#ifndef STASSID
#define STASSID "Bbox-xxxxxxx"
#define STAPSK  "xxxxxxxxxxxxxxxxxxxxxxxx"
#endif
#define DHT11_PIN D3
dht DHT;

const char* ssid = STASSID;
const char* password = STAPSK;

// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80);

void setup() {
  Serial.begin(115200);

  // prepare LED
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 0);

  // Connect to WiFi network
  Serial.println();
  Serial.println();
  Serial.print(F("Connecting to "));
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(F("."));
  }
  Serial.println();
  Serial.println(F("WiFi connected"));

  // Start the server
  server.begin();
  Serial.println(F("Server started"));

  // Print the IP address
  Serial.println(WiFi.localIP());
}

void loop() {
  
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }
  Serial.println(F("new client"));

  client.setTimeout(5000); // default is 1000

  // Read the first line of the request
  String req = client.readStringUntil('\r');
  Serial.println(F("request: "));
  Serial.println(req);

  // Match the request

   // serial println avec dht 11
   // test dht_11
   //lecture capteur 
   int chk = DHT.read11(DHT11_PIN);
  // affichage données
  Serial.print("Command is : [");
  Serial.println(" is to show temperature!] ");
  Serial.print(" Temp is: " );
  Serial.print(DHT.temperature);
  Serial.println(" ° C. Degrés Celcius");
   
  Serial.print("Command is : [");
  Serial.println("to show humidity!]");
  Serial.print(" Humidity is: " );
  Serial.print(DHT.humidity);
  Serial.println(" % pour cent ");  

  Serial.println("quelle est la requète ?");
  int val;
  if (req.indexOf(F("/gpio/0")) != -1) {
    val = 1;
    Serial.println(" demande d'extinction de la led ");
  } else if (req.indexOf(F("/gpio/1")) != -1) {
    val = 0;
    Serial.println(" demande d'allumage de la led");
  } else {
    Serial.println(F("invalid request"));
    val = digitalRead(LED_BUILTIN);
  }

  // Set LED according to the request
  digitalWrite(LED_BUILTIN, val);
  Serial.println(" on réponds à la requète ");
  // read/ignore the rest of the request
  // do not client.flush(): it is for output only, see below
  while (client.available()) {
    // byte by byte is not very efficient
    client.read();
  }

  // Send the response to the client
  // it is OK for multiple small client.print/write,
  // because nagle algorithm will group them into one single packet
  Serial.println("envoi de la page web au client");
  client.print(F("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO is now "));
  client.print((val) ? F("high") : F("low"));
  client.print(F("<br><br>Click <a href='http://"));
  client.print(WiFi.localIP());
  client.print(F("/gpio/1'>here</a> to switch LED GPIO on, or <a href='http://"));
  client.print(WiFi.localIP());
  client.print(F("/gpio/0'>here</a> to switch LED GPIO off.</html>"));

  // The client will actually be *flushed* then disconnected
  // when the function returns and 'client' object is destroyed (out-of-scope)
  // flush = ensure written data are received by the other side
  Serial.println(F("Disconnecting from client"));
}

si qqun pouvait me communiquer des ressources faciles à comprendre (à la portée d’un débutant),

voire des exemples de programmes simple à comprendre afin que je puisse les appliquer à mon cas …

ce serai sympa .

merci .

+0 -0

Bonjour,

Que veux-tu dire par :

dans la page html , je sais pas faire ….

Quel est le problème exactement ? A quel niveau ton code bloque-t-il ?

Aussi, je remarque que tu n’attribues pas d’IP fixe à la carte, ce qui signifie que tu as besoin de la liaison série pour la connaître (ligne 58). Auras-tu toujours accès à cette liaison série ?

+1 -0

Bonjour et bienvenue sur Zeste de Savoir.

  1. Est-ce que tu arrive à accéder à la page renvoyée par l’Arduino ?
  2. Est-ce que tu arrive à allumer/éteindre la LED_BUILTIN depuis la page HTML renvoyée par le code actuel ?
  3. Est-ce que tu as des bases en HTML ? Est-ce que tu comprends le HTML envoyé entre les lignes 123 et 129 ?
+1 -0

j’ai réussi , pour partie , à faire ce que je voulais .

/*
    This sketch demonstrates how to set up a simple HTTP-like server.
    The server will set a GPIO pin depending on the request
      http://server_ip/gpio/0 will set the GPIO2 low,
      http://server_ip/gpio/1 will set the GPIO2 high
    server_ip is the IP address of the ESP8266 module, will be
    printed to Serial when the module is connected.
*/

// librairies :
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <dht.h>

// initialisations :
#ifndef STASSID
#define STASSID "Bbox-9F38B11F"
#define STAPSK  "5556E12CFF4553C1E734A347636EF6"
#endif
#define DHT11_PIN D3
dht DHT;

const char* ssid = STASSID;
const char* password = STAPSK;

// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80);

void setup() {
  Serial.begin(115200);

  // prepare LED
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 0);

  // Connect to WiFi network
  Serial.println();
  Serial.println();
  Serial.print(F("Connecting to "));
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(F("."));
  }
  Serial.println();
  Serial.println(F("WiFi connected"));

  // Start the server
  server.begin();
  Serial.println(F("Server started"));

  // Print the IP address
  Serial.println(WiFi.localIP());
}

void loop() {
  
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }
  Serial.println(F("new client"));

  client.setTimeout(5000); // default is 1000

  // Read the first line of the request
  String req = client.readStringUntil('\r');
  Serial.println(F("request: "));
  Serial.println(req);

  // Match the request

   // serial println avec dht 11
   // test dht_11
   //lecture capteur 
   int chk = DHT.read11(DHT11_PIN);
  // affichage données
  Serial.print("Command is : [");
  Serial.println(" is to show temperature!] ");
  Serial.print(" Temp is: " );
  Serial.print(DHT.temperature);
  Serial.println(" ° C. Degrés Celcius");
   
  Serial.print("Command is : [");
  Serial.println("to show humidity!]");
  Serial.print(" Humidity is: " );
  Serial.print(DHT.humidity);
  Serial.println(" % pour cent ");  

  Serial.println("quelle est la requète ?");
  int val;
  if (req.indexOf(F("/gpio/0")) != -1) {
    val = 1;
    Serial.println(" demande d'extinction de la led ");
  } else if (req.indexOf(F("/gpio/1")) != -1) {
    val = 0;
    Serial.println(" demande d'allumage de la led");
  } else {
    Serial.println(F("invalid request"));
    val = digitalRead(LED_BUILTIN);
  }

  // Set LED according to the request
  digitalWrite(LED_BUILTIN, val);
  Serial.println(" on réponds à la requète ");
  // read/ignore the rest of the request
  // do not client.flush(): it is for output only, see below
  while (client.available()) {
    // byte by byte is not very efficient
    client.read();
  }

  // Send the response to the client
  // it is OK for multiple small client.print/write,
  // because nagle algorithm will group them into one single packet
  Serial.println("envoi de la page web au client");
  client.print(F("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO est maintenant "));
  client.println((val) ? F(" eteint") : F(" allume"));

  client.print("<br><br>");
  client.print("  la temperature est de  : ");
  client.print(DHT.temperature);
  client.print(" C. Degres Celcius ");
  client.print("<br><br>le taux d'humidite est de : ");
  client.print(DHT.humidity);
  client.print(" % pour cent ");
  
  client.print(F("<br><br>Cliquez  <a href='http://"));
  client.print(WiFi.localIP());
  client.print(F("/gpio/1'> ici </a> pour allumer la LED Integree , ou <a href='http://"));
  client.print(WiFi.localIP());
  client.print(F("/gpio/0'> ici </a> pour l'eteindre . </html>"));

  // The client will actually be *flushed* then disconnected
  // when the function returns and 'client' object is destroyed (out-of-scope)
  // flush = ensure written data are received by the other side
  Serial.println(F("Disconnecting from client"));
}

console série :

16:10:37.432 -> ⸮⸮H⸮new client
16:10:58.331 -> request: 
16:10:58.331 -> GET / HTTP/1.1
16:10:58.364 -> Command is : [ is to show temperature!] 
16:10:58.364 ->  Temp is: 26.00 ° C. Degrés Celcius
16:10:58.364 -> Command is : [to show humidity!]
16:10:58.364 ->  Humidity is: 28.00 % pour cent 
16:10:58.364 -> quelle est la requète ?
16:10:58.364 -> invalid request
16:10:58.364 ->  on réponds à la requète 
16:10:58.364 -> envoi de la page web au client
16:10:58.398 -> Disconnecting from client
16:10:58.431 -> new client
16:10:58.431 -> request: 
16:10:58.431 -> GET /favicon.ico HTTP/1.1
16:10:58.464 -> Command is : [ is to show temperature!] 
16:10:58.464 ->  Temp is: 26.00 ° C. Degrés Celcius
16:10:58.464 -> Command is : [to show humidity!]
16:10:58.464 ->  Humidity is: 28.00 % pour cent 
16:10:58.464 -> quelle est la requète ?
16:10:58.506 -> invalid request
16:10:58.506 ->  on réponds à la requète 
16:10:58.506 -> envoi de la page web au client
16:10:58.506 -> Disconnecting from client
16:11:08.666 -> new client
16:11:08.666 -> request: 
16:11:08.666 -> GET /gpio/0 HTTP/1.1
16:11:08.699 -> Command is : [ is to show temperature!] 
16:11:08.699 ->  Temp is: 26.00 ° C. Degrés Celcius
16:11:08.699 -> Command is : [to show humidity!]
16:11:08.699 ->  Humidity is: 28.00 % pour cent 
16:11:08.699 -> quelle est la requète ?
16:11:08.699 ->  demande d'extinction de la led 
16:11:08.699 ->  on réponds à la requète 
16:11:08.699 -> envoi de la page web au client
16:11:08.733 -> Disconnecting from client
16:11:08.766 -> new client
16:11:08.766 -> request: 
16:11:08.766 -> GET /favicon.ico HTTP/1.1
16:11:08.799 -> Command is : [ is to show temperature!] 
16:11:08.799 ->  Temp is: 26.00 ° C. Degrés Celcius
16:11:08.799 -> Command is : [to show humidity!]
16:11:08.799 ->  Humidity is: 28.00 % pour cent 
16:11:08.799 -> quelle est la requète ?
16:11:08.799 -> invalid request
16:11:08.799 ->  on réponds à la requète 
16:11:08.799 -> envoi de la page web au client
16:11:08.832 -> Disconnecting from client

Aussi, je remarque que tu n’attribues pas d’IP fixe à la carte, ce qui signifie que tu as besoin de la liaison série pour la connaître (ligne 58). Auras-tu toujours accès à cette liaison série ?

ben non , bien sur , je n’aurai pas toujours la liaison série sous le coude …

le but , c’est de le rendre autonome .

j’ai mal répondu dans mon message précédent .

Aussi, je remarque que tu n’attribues pas d’IP fixe à la carte, ce qui signifie que tu as besoin de la liaison série pour la connaître (ligne 58). Auras-tu toujours accès à cette liaison série ?

oui , c’est volontaire (et aussi un peu forcé : je sais pas comment faire) : je préfère laisser le dhcp de la box attribuer les adresses , pour l’instant .

Est-ce que tu arrive à accéder à la page renvoyée par l’Arduino ? Est-ce que tu arrive à allumer/éteindre la LED_BUILTIN depuis la page HTML renvoyée par le code actuel ?

oui, de ce côté là , même en alimentant la carte avec l’alim de mon téléphone portable , çà marche O.K. . pas de souci de fonctionnement , pas de souci d' i.p.

Est-ce que tu as des bases en HTML ? Est-ce que tu comprends le HTML envoyé entre les lignes 123 et 129 ?

je n’ai quasiment aucune base en programmation . juste , il y a 20 ans au moins , une initiation à la programmation en pascal , en assembleur Z80 , 6809 , automates télémécanique TSX et April … c’est tout .

j’ai essayé de suivre une formation de base en html il y a 10 ans : les déplacements incessants partout en bretagne ont eu raison de mes capacités intellectuelles et de ma bonne volonté .

pour le code : entre les lignes 126 et 132 incluses , je sais ce que j’ai fait , je le comprends très bien . c’est le fruit de mon travail et de mes réflexions .

en ce qui concerne les lignes 134 à 138 incluses : j’ai beaucoup de mal à les comprendre . il semble qu’elles envoient la commande 'gpio/1' ou 'gpio/0' en fonction du bouton 'ici' qui est cliqué .

en ce qui concerne les lignes 122 à 124 : apparemment , elles affichent un 'voyant' en fonction de l’état binaire d’une variable . mais d’où sort elle , cette variable ? (val) ???

Bonjour à toi et bienvenue ici :)

Bon, nous avons plus ou moins déjà commencé la discussion ailleurs ;)

en ce qui concerne les lignes 122 à 124 : apparemment , elles affichent un 'voyant' en fonction de l’état binaire d’une variable . mais d’où sort elle , cette variable ? (val) ???

Elle est définie ligne 97, et sa valeur est définie entre les lignes 98 et 107, en fonction de ce qui se trouve dans la variable req définie ligne 73.

Cette variable est de type String, et contient la requête envoyé à l’ESP, récupérée grâce à la méthode readStringUntil().

Donc, dans les lignes 98 à 107, si la requête contient le texte /gpio/0, val prend la valeur 1, et si la requête contient /gpio/1, elle prend alors la valeur 0. La méthode indexOf() est utilisée pour déterminer si la requête contient l’une ou l’autre de ces sous-chaîne.

en ce qui concerne les lignes 134 à 138 incluses : j’ai beaucoup de mal à les comprendre . il semble qu’elles envoient la commande 'gpio/1' ou 'gpio/0' en fonction du bouton 'ici' qui est cliqué .

Les lignes 134 à 138 construisent par envois successifs, la partie de page HTML avec les liens contenant les URL http://IP_ESP/gpio/1 et http://IP_ESP/gpio/0. Ce sont ces liens que tu va cliquer, qui généreront une requête analysée par l’ESP et qui en déterminera la valeur de val utilisée pour déterminer l’état d la LED intégrée :) Les chaînes de caractères invariantes (balises etc..) sont stockées non pas en mémoire vive (pour l’économiser), mais en mémoire Flash grâce à la syntaxe F("Ma chaîne"). C’est au moment de la compilation et du transfert du binaire que ça se fait.

Voilà, je t’ai mis pas mal de lien vers la doc officielle de l’Arduino, c’est en anglais, mais c’est quand même la référence. En fouinant un peu, je suis tombé sur une traduction de cette documentation , mais je ne suis pas certain que ça soit à jour.

En fait, la bonne démarche pour apprendre ce langage, si tu ne veux pas suivre de tuto ou de MOOC (il y a une progression dans ces formations, donc, c’est plus facile, mais ça ne correspond pas forcement à ce que tu veux réaliser), c’est tout d’abord, être à l’aise avec les structures (conditionnelles, boucles …) et la syntaxe, puis lorsque tu tombes sur des fonctions que tu ne connais pas, d’en rechercher le fonctionnement dans la doc. Mais c’est peut-être plus compliqué que de suivre un cours.

Encore un fois comme dit ailleurs, prends ton temps ;)

merci bendia .

comme suggéré ailleurs par toi , je me penche actuellement sur le mqtt de l' ESP .

trouvé ce programme dans l’I.D.E. (le seul à ma connaissance) :

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <PubSubClientTools.h>

#include <Thread.h>             // https://github.com/ivanseidel/ArduinoThread
#include <ThreadController.h>

#define WIFI_SSID "Bbox-xxxxxxxxx"
#define WIFI_PASS "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
#define MQTT_SERVER "broker.mqtt-dashboard.com"

WiFiClient espClient;
PubSubClient client(MQTT_SERVER, 1883, espClient);
PubSubClientTools mqtt(client);

ThreadController threadControl = ThreadController();
Thread thread = Thread();

int value = 0;
String s = "";

void setup() {
  Serial.begin(115200);

  // Connect to WiFi
  Serial.print(s+"Connecting to WiFi: "+WIFI_SSID+" ");
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println(s+" connected with IP: "+WiFi.localIP());

  // Connect to MQTT
  Serial.print(s+"Connecting to MQTT: "+MQTT_SERVER+" ... ");
  if (client.connect("ESP8266Client")) {
    Serial.println("connected");

    mqtt.subscribe("test/inTopic1", topic1_subscriber);
    mqtt.subscribe("test/inTopic2", topic2_subscriber);
  } else {
    Serial.println(s+"failed, rc="+client.state());
  }

  // Enable Thread
  thread.onRun(publisher);
  thread.setInterval(2000);
  threadControl.add(&thread);
}

void loop() {
  client.loop();
  threadControl.run();
}

void publisher() {
  ++value;
  mqtt.publish("test/outTopic", s+"hello world "+value);
}
void topic1_subscriber(String topic, String message) {
  Serial.println(s+"Message arrived in function 1 ["+topic+"] "+message);
}
void topic2_subscriber(String topic, String message) {
  Serial.println(s+"Message arrived in function 2 ["+topic+"] "+message);
}
Image MQTT Box chez moi
Image MQTT Box chez moi

je dois mettre quoi dans

  • topic to subscribe
  • topic to publish

???

je ne comprends pas le programme …

un programme que je comprends à peu près et qui fonctionne ….

/*  ___   ___  ___  _   _  ___   ___   ____ ___  ____  
 * / _ \ /___)/ _ \| | | |/ _ \ / _ \ / ___) _ \|    \ 
 *| |_| |___ | |_| | |_| | |_| | |_| ( (__| |_| | | | |
 * \___/(___/ \___/ \__  |\___/ \___(_)____)___/|_|_|_|
 *                  (____/ 
 * Use NodeMCU to drive DHT11 and send temperature/humidity value to MQTT server
 * Tutorial URL http://osoyoo.com/2016/11/24/use-nodemcu-to-send-temperaturehumidity-data-to-mqtt-iot-broker/
 * CopyRight www.osoyoo.com
 */
#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include<dht.h>
dht DHT;

// Define NodeMCU D3 pin to as temperature data pin of  DHT11
#define DHT11_PIN D3

// Define external led
#define LED D1  // ne sert à rien , normalement 

// Update these with values suitable for your network.
const char* ssid = "Bbox-xxxxx";
const char* password = "xxxxxxxxxxxxxxxxxx";
const char* mqtt_server = "broker.mqtt-dashboard.com";
//const char* mqtt_server = "iot.eclipse.org";

WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;

void setup_wifi() {
   delay(100);
  // We start by connecting to a WiFi network
    Serial.print("Connecting to ");
    Serial.println(ssid);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) 
    {
      delay(500);
      Serial.print(".");
    }
  randomSeed(micros());
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void callback(char* topic, byte* payload, unsigned int length) 
{
  Serial.print("Command is : [");
  Serial.print(topic);
  int p =(char)payload[0]-'0';
  int chk = DHT.read11(DHT11_PIN);
  // if MQTT comes a 0 message, show humidity
  if(p==0) 
  {
    Serial.println("to show humidity!]");
    Serial.print(" Humidity is: " );
    Serial.print(DHT.humidity, 1);
    Serial.println('%');
  } 
  // if MQTT comes a 1 message, show temperature
  if(p==1)
  {
  // digitalWrite(BUILTIN_LED, LOW);

   Serial.println(" is to show temperature!] ");
  int chk = DHT.read11(DHT11_PIN);
   Serial.print(" Temp is: " );
   Serial.print(DHT.temperature, 1);
   Serial.println(' C');
  }
  Serial.println();
} //end callback

void reconnect() {
  // Loop until we're reconnected
  while (!client.connected()) 
  {
    Serial.print("Attempting MQTT connection...");
    // Create a random client ID
    String clientId = "ESP8266Client-";
    clientId += String(random(0xffff), HEX);
    // Attempt to connect
    //if you MQTT broker has clientID,username and password
    //please change following line to    if (client.connect(clientId,userName,passWord))
    if (client.connect(clientId.c_str()))
    {
      Serial.println("connected");
     //once connected to MQTT broker, subscribe command if any
      client.subscribe("AlainCommand");
    } else {
      Serial.print("failed, rc=");
      Serial.print(client.state());
      Serial.println(" try again in 5 seconds");
      // Wait 6 seconds before retrying
      delay(6000);
    }
  }
} //end reconnect()

void setup() {
  Serial.begin(115200);            // mise en place lien série 
  // pinMode(LED_BUILTIN, OUTPUT); // led interne en output 
  setup_wifi();                    // mise en place wifi
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  int chk = DHT.read11(DHT11_PIN);
  Serial.print(" Starting Humidity: " );
  Serial.print(DHT.humidity, 1);
  Serial.println(' %');
  Serial.print(" Starting Temparature ");
  Serial.print(DHT.temperature, 1);
  Serial.println(' C');
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
  long now = millis();
  // read DHT11 sensor every 10 seconds
  if (now - lastMsg > 10000) {
     lastMsg = now;
     int chk = DHT.read11(DHT11_PIN);
     String msg="Temperature reelle : ";
     msg= msg+ DHT.temperature;
     msg = msg+" C ; Humidite reelle : " ;
     msg=msg+DHT.humidity ;
     msg=msg+" %";
     char message[58];
     msg.toCharArray(message,58);
     Serial.println(message);
     //publish sensor data to MQTT broker
    client.publish("AlainData", message);
  }
}

la console série :

18:09:10.021 ->  1384, room 16 
18:09:10.021 -> tail 8
18:09:10.021 -> chksum 0x2d
18:09:10.021 -> csum 0x2d
18:09:10.021 -> v21db8fc9
18:09:10.021 -> ~ld
18:09:16.292 -> Temperature reelle : 26.00 C ; Humidite reelle : 23.00 %
18:09:26.297 -> Temperature reelle : 26.00 C ; Humidite reelle : 23.00 %
18:09:35.009 -> Attempting MQTT connection...failed, rc=-2 try again in 5 seconds
18:09:41.005 -> Attempting MQTT connection...connected
18:09:41.105 -> Temperature reelle : 26.00 C ; Humidite reelle : 22.00 %
18:09:51.109 -> Temperature reelle : 26.00 C ; Humidite reelle : 22.00 %
18:09:58.662 -> Command is : [AlainCommandto show humidity!]
18:09:58.696 ->  Humidity is: 22.0%
18:09:58.696 -> 
18:10:01.113 -> Temperature reelle : 26.00 C ; Humidite reelle : 23.00 %
18:10:05.949 -> Command is : [AlainCommand is to show temperature!] 
18:10:05.982 ->  Temp is: 26.08259
18:10:05.982 -> 
18:10:11.117 -> Temperature reelle : 26.00 C ; Humidite reelle : 19.00 %
18:10:21.121 -> Temperature reelle : 26.00 C ; Humidite reelle : 22.00 %
18:10:31.122 -> Temperature reelle : 26.00 C ; Humidite reelle : 22.00 %
18:10:41.125 -> Temperature reelle : 26.00 C ; Humidite reelle : 22.00 %

copie d’ecran MQTTBox linux debian

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte