ESP8266 (Client Web) : envoyer des données à Jeedom en TCP/IP sans fil (API JSON) – Partie 1

Nous continuons notre série d’articles sur l’échange de données par requêtes HTTP (TCP/IP) entre un ESP8266 et le serveur domotique Jeedom. Jeedom met à disposition une API aussi complète que celle de Domoticz. La documentation est disponible ici. Nous irons un peu plus vite que pour Domoticz, le principe général étant le même.

Lectures recommandées

ESP8266 (Client Web) : envoyer des données à Domoticz en TCP/IP sans fil (API/JSON) – Partie 1

ESP Easy : utiliser des objets connectés DIY avec Jeedom

Documentation API JSON RPC Jeedom

Matériel utilisé

Le circuit reste le même, à savoir une Wemos D1 Mini (ESP8266 ESP-12), un capteur de température et d’humidité (DHT22), un capteur de pression atmosphérique (BMP180) ainsi qu’un shield relai pour piloter l’allumage d’un appareil depuis l’interface de Jeedom.

esp8266 Wemos D1 mini Module ESP8266 ESP-12. Par exemple Wemos D1 Mini
BMP180 Capteur de pression atmosphérique

BMP180

Broches DHT22 Capteur de température et d’humidité

DHT11 ou DHT22

wemos d1 mini dht22 shield Shield DHT22 ou DHT11 pour Wemos D1 Mini

Le capteur est connecté à la broche D4 (GPIO2)

wemos d1 mini relai shield Shield relai  (250VAC/10A ou 30VDC/10A) pour Wemos D1 Mini
led 3mm Led (visualiser l’activation / désactivation du GPIO )
resistance 220ohms Résistance 220Ω
jumper dupont Jumper Dupont
breadboard Breadboard

Circuit : une mini station météo connectée

Composant Broches Broche ESP8266 (Wemos D1 mini)
DHT22 (shield Wemos D1 Mini) VCC 3V3
GND G
Data D4
BMP180 VCC 3V3
GND G
SDA D2
SCK D3
Shield relai Wemos D1 Mini D1

ESP8266 DHT22 BMP180 Shield Relay jeedom ESP8266HTTPCLIENT

 

Récupérer votre clé API Jeedom

Pour pouvoir transmettre des données à Jeedom, il est nécessaire de récupérer la clé API depuis l’interface d’administration. Connectez vous à votre serveur et allez dans la configuration (roues crantées). Elle se trouve dans le champ clef API. Vous aurez besoin de cette clé pour le code Arduino.

Remarque. Il est possible de générer une nouvelle clé. Tous les appareils qui utilisent cette clé ne pourront plus utiliser l’API JSON (c’est le but après tout).

 jeedom api key esp8266 http api json

Préparer un instrument virtuel

Nous allons maintenant créer un instrument qui va recevoir les données. Allez dans les plugins et vérifiez que le plugin Instrument Virtuel est installé. Si ce n’est pas le cas, faites-le.

jeedom instrument virtuel

Rendez-vous dans plugins -> Programmation -> Virtuel et cliquer sur + pour créer un nouveau instrument :

  • Donnez lui un nom
  • Un objet
  • Un type (optionnel)
  • Cochez Activer et Visible

 jeedom equipement virtuel esp8266 wemos api jsonAllez ensuite à l’onglet Commandes et ajoutez 3 infos virtuelles : température, humidité, baromètre. Vous pouvez en profiter pour attribuer une étiquette pour l’unité ainsi qu’une valeur mini et maxi pur l’échelle. Sauvegardez. Après la sauvegarde, un identifiant (#) est attribué pour chaque information virtuelle. Ici, température (#78), humidité (#79) et baromètre (#80). Nous en aurons besoin dans le code Arduino.

 jeedom equipement virtuelle commandes temperature humidite api json esp8266 wemos

Code Arduino/ESP8266

C’est exactement le même que celui développé pour Domoticz, il n’y a que la construction de la requête HTTP qui change. Contrairement à Domoticz, on doit envoyer les données séparément, c’est à dire celle qui correspond à l’instrument virtuel.

La requête HTTP prend la forme suivante

http://#IP_JEEDOM#/core/api/jeeApi.php?apikey=#APIKEY#&type=virtual&id=#ID#&value=#value#

Pour faciliter le travail, vous trouverez au début du programme les variables suivantes qu’il vous reste à modifier par vos valeurs :

const char* apiKey   = "mVuQikcXm69l2mDMYZiCsLj0wamT0HsCcrBCuXRxntJDO1kn";
const char* idTemp   = "78";
const char* idHumi   = "79";
const char* idPA     = "80";

On va donc devoir envoyer une requête HTTP pour chaque mesure et l’envoyer à l’instrument virtuel correspondant. La fonction SendToJeedom() utilise la librairie ESP8266HTTPClient pour envoyer la requête de type Get (les données étant encodées dans l’URL). En retour Jeedom, renvoi le code 200 si tout s’est bien passé. Si la clé API est mauvaise, la librairie ESP8266HTTPClient renvoi l’erreur -11 (HTTPC_ERROR_READ_TIMEOUT). Jeedom reste muet tout simplement.

boolean sendToJeedom(String url){
  Serial.print("connecting to ");
  Serial.println(host);
  Serial.print("Requesting URL: ");
  Serial.println(url);
  http.begin(host,port,url);
  int httpCode = http.GET();
  Serial.println("closing connection");
  http.end();
}

La requête reste un simple chaine de caractère que l’on assemble avec les différentes variables, par exemple pour la température

String baseurl = "/core/api/jeeApi.php?apikey="; 
baseurl += apiKey;
baseurl += "&type=virtual&id="; 

String url = baseurl + idTemp;
url += url + "&value="; url += String(t); 
sendToJeedom(url);
delay(1000);

Ce qui donne par exemple la requête suivante

/core/api/jeeApi.php?apikey=mVuQikcXm69l2mDMYZiCsLj0wamT0HsCcrBCuXRxntJDO1kn&type=virtual&id=78&value=19.8

Il suffit ensuite de reprendre la base de l’url (baseurl) qui est toujours identique et l’assembler avec l’identifiant et sa valeur. J’ai ajouté un délai de 1s entre chaque publication. Pour optimiser le code, on pourrait vérifier que l’envoi précédent a été correct avant de poursuivre.

Ouvrez l’IDE Arduino et collez le code suivant. Modifiez les variables et téléversez-le.

/*
 * HTTP communication between ESP8266 and Jeedom Smart Home Server
 * Communication HTTP (TCP/IP) entre ESP8266 et le serveur domotique Jeedom
 * Copyright (C) 2017 https://www.projetsdiy.fr - http://www.diyprojects.io
 *   
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <ESP8266WebServer.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>
#include <WiFiClientSecure.h>
#include <DHT.h>
#include <Adafruit_BMP085.h>

#define DHTTYPE   DHT22       // DHT type (DHT11, DHT22)
#define DHTPIN    D4          // Broche du DHT / DHT Pin

const char* ssid     = "xxxxxxxx";
const char* password = "xxxxxxxx";
const char* host     = "xxx.xxx.xxx.xxx";
const int   port     = 80;
const char* apiKey   = "mVuQikcXm69l2mDMYZiCsLj0wamT0HsCcrBCuXRxntJDO1kn";
const char* idTemp   = "78";
const char* idHumi   = "79";
const char* idPA     = "80";
const int   watchdog = 60000;
unsigned long previousMillis = millis(); 
const uint8_t GPIOPIN[5] = {D1,D5,D6,D7,D8};  // Led

DHT dht(DHTPIN, DHTTYPE);
Adafruit_BMP085 bmp;
ESP8266WebServer server ( 80 );
HTTPClient http;

void updateGpio(){
  Serial.println("Update GPIO command from Jeedom : ");
  for ( int i = 0 ; i < server.args(); i++ ) {
    Serial.print(server.argName(i)); Serial.println(server.arg(i));
  }
  String gpio = server.arg("id"); 
  String token = server.arg("token");
  // Vérifie si le serveur est autorisé - Check if server is authorized
  if ( token != "123abCde" ) {
    Serial.println("Not authentified ");
    return;
  }
  int etat = server.arg("etat").toInt();
  int pin = D1;
  if ( gpio == "D1" ) {
    pin = D1;
  } else if ( gpio == "D7" ) {
    pin = D7;
  } else if ( gpio == "D8" ) {
    pin = D8;  
  } else {   
    pin = D1;
  }
  Serial.print("Update GPIO "); Serial.println(pin);
  if ( etat == 1 ) {
    digitalWrite(pin, HIGH);
    Serial.println("GPIO updated : On");
    server.send(200, "application/json","success:1");
  } else if ( etat == 0 ) {
    digitalWrite(pin, LOW);
    Serial.println("GPIO updated : Off");
    server.send(200, "application/json","success:1");
  } else {
    Serial.println("Bad state Value !");
    server.send(200, "application/json","success:0");
  }
}

void setup() {
  Serial.begin(115200);
  delay(10);
  
  Wire.begin(D2,D3);            // Modifie les broches du bus I2C - Change I2C Pins
  if ( !bmp.begin() ) {
    Serial.println("BMP180 KO!");
    while (1);
  } else {
    Serial.println("BMP180 OK");
  }
  
  Serial.setDebugOutput(true);  
  Serial.println("Connecting Wifi...");

  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  
  for ( int x = 0 ; x < 5 ; x++ ) {
    pinMode(GPIOPIN[x], OUTPUT);
  }
  
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.print(WiFi.localIP()); 
  
  server.on("/gpio", updateGpio);
  server.begin();
}

int value = 0;

void loop() {
  server.handleClient();
  unsigned long currentMillis = millis();

  if ( currentMillis - previousMillis > watchdog ) {
    previousMillis = currentMillis;

    if(WiFi.status() != WL_CONNECTED) {
      Serial.println("WiFi not connected !");
    } else {  
      Serial.println("Send data to Jeedom");
      
      float t = dht.readTemperature();
      float h = dht.readHumidity();
      float pa = bmp.readPressure() / 100.0F;
      
      if ( isnan(t) || isnan(h) ) {
        Serial.println("DHT KO");
      } else {
        String baseurl = "/core/api/jeeApi.php?apikey="; 
        baseurl += apiKey;
        baseurl += "&type=virtual&id="; 
        String url = baseurl + idTemp;
        url += url + "&value="; url += String(t); 
        sendToJeedom(url);
        delay(1000);
        
        url = baseurl + idHumi;
        url += url + "&value="; url += String(h);
        sendToJeedom(url);
        delay(1000);

        url = baseurl + idPA;
        url += url + "&value="; url += String(pa);
        sendToJeedom(url);
        delay(1000);
      }
    }
  }
}

boolean sendToJeedom(String url){
  Serial.print("connecting to ");
  Serial.println(host);
  Serial.print("Requesting URL: ");
  Serial.println(url);
  http.begin(host,port,url);
  int httpCode = http.GET();
  Serial.println("closing connection");
  http.end();
}

De retour sur l’interface Jeedom, vous pouvez visualiser les mesures qui remontent de l’ESP8266 sur l’instrument virtuel.

jeedom api json wemos d1 mini dht22 bmp180 esp8266httpclient

Print Friendly, PDF & Email

Inscrivez-vous à la newsletter hebdomadaire

Aucun spam et aucun autre usage ne sera fait de votre email. Vous pouvez vous désinscrire à tout moment.

Comparateur de prix

Bons plans

Les offres suivantes se terminent bientôt. Utilisez le coupon indiqué pour profiter du prix promo

Domotique et objets connectés à faire soi-même