Fabriquer une solution déportée et indépendante pour suivre sa consommation électrique en temps réel pour moins de 10€ (xKyMS Prototype en cours)

Fabriquer une solution déportée et indépendante pour suivre sa consommation électrique en temps réel pour moins de 10€ (xKyMS Prototype en cours)

12 septembre 2022 1 Par Jérôme Ferrari

Bonjour à tous,

Aujourd’hui, je vous propose de fabriquer une solution permettant de suivre en temps réel sa consommation électrique et de l’afficher sur un écran LCD pour moins de 10€. Elle a pour but d’être complémentaire au Linky.

Cette solution, au départ, a été imaginée dans le cadre de l’OTE (Observatoire de la Transition Energétique) afin de permettre aux personnes voulant participer aux futures expérimentations d’ouvrir leurs données tout en gardant la maitrise de celles-ci.

A l’heure où j’écris ces lignes, seulement le code de la partie MQTT dans le périmètre Domicile avec une fonction basique permettant d’afficher la puissance consommée en se servant de la prise TIC du Linky sera abordée.

Je ferai évoluer cet article ou j’en écrirai un autre au fur et à mesure des avancées. N’hésitez pas à faire des retours sur les fonctionnalités que vous souhaitez voir intégrer dedans.

Comme d’habitude, il s’agit d’une solution Open-Source CC-BY-NC-SA et les sources et codes seront en fin d’article ainsi que sur le Gitlab du projet https://gricad-gitlab.univ-grenoble-alpes.fr/ferrarij/xky

Partie 0: Liste du matériel

  • Un dispositif permettant de lire la prise TIC et de renvoyer l’information via MQTT
    • Comme j’ai développé le Winky je prendrais cette base, mais tout autre système faisant l’équivalent fonctionnera
  • 2 Board comportant un ESP8266 (exemple: Wemos W1 mini, NodeMCU….) Ici pour des raisons de debuggage et d’accès aux pins je pars sur un NodeMCU
  • Un écran lcd avec communication I2C (ici je suis parti sur un écran de 0.91 pouces)
  • Quelques fils

Partie 1: Préparation du Broker MQTT

La première étape est de fabriquer un broker MQTT permettant de publier et de s’inscrire sur des topics afin de permettre aux différents éléments de la solution de dialoguer ensemble.

Si vous voulez plus de détails sur le protocole MQTT, je vous conseille cet article du LeMagIT

https://www.lemagit.fr/conseil/Internet-des-Objets-bien-comprendre-MQTT

Maintenant que les présentations sont faites, nous pouvons passer à la partie la plus compliquée, le codage ^^.

La première étape de configurer l’IDE Arduino correctement:

Pour cela, il faut prendre la librairie TinyMqtt de HSaturn

https://github.com/hsaturn/TinyMqtt

Pour cela, une fois l’IDE arduino démarré, allez dans Outils–> Gérer les bibliothèques

Recherche TimMqtt et cliquez sur installer

Voilà vous pouvez fermer et maintenant vous pouvez chercher l’exemple simple-broker en cliquant sur Fichier –> Exemples –> TinyMqtt –> simple-broker

Dans cet exemple, il faut renseigner le SSID et le password de votre réseau Wifi

Une fois cela fait, il faut brancher l’ESP8266 sur l’ordinateur, vérifier que tout est ok dans la configuration et mettre le bon port COM

Vous pouvez téléverser

Maintenant, il faut ouvrir le moniteur série pour récupérer l’adresse IP du Broker franchement installé

Pour la suite des opérations, gardez le Broker branché sur le port COM (cela vous aidera pour le débuggage et une fois l’installation finie, vous pourrez le brancher ailleurs que sur votre PC.

Si tout est ok, on peut passer à la configuration du Winky ou d’un autre dispositif

Partie 2: Préparation de la publication des messages via le Winky ou autres dispositifs

Pour cette partie, je vous renvois sur l’article https://miniprojets.net/index.php/2022/02/04/winky-version-2-open-source-projet-pour-linky-avec-wifi/ qui vous explique comment fabriquer un Winky

En ce qui concerne la configuration, il faudra mettre les renseignements suivants:

  • le SSID et le password
  • L’adresse IP du Broker récupérée précédemment
  • Un topic ici comme le Broker est simple, il faudra modifier les lignes suivantes

Par

Voilà maintenant que cela est ok, vous pouvez téléverser le programme et brancher votre Winky sur le Linky

Normalement, si tout c’est bien passé vous verrez apparaitre sur le moniteur du Broker ce genre de message “Connected client: xxxxxx keep alive”

Si tout est ok, nous pouvons passer à l’étape suivante qui consiste à fabriquer et coder l’écran déporté.

Partie 3: Fabrication du xKy MasterSystem

Pour ce dispositif, nous allons partir sur la version la plus simple qui soit. C’est-à-dire un NodeMCU et un écran I2C, on étoffera au fur et à mesure des semaines et des retours.

Pour commencer, il faut brancher l’écran lcd au nodeMCU en les connectant de la manière suivante:

NodeMCUEcran LCD
3.3VVCC
GNDGND
D1SCL
D2SDA

Ensuite, nous pouvons configurer l’IDE Arduino. Pour cela, il faut déjà ajouter les librairies Adafruit_GFX, Adafruit_SSD1306 et PubSubClient.

Une fois cela fait, vous pouvez copier/coller le code suivant et mettre les informations du SSID, du Mot de passe Wifi et de l’adresse IP du broker MQTT

#include <ESP8266WiFi.h>
#include <PubSubClient.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 32 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
// The pins for I2C are defined by the Wire-library. 
// On an arduino UNO:       A4(SDA), A5(SCL)
// On an arduino MEGA 2560: 20(SDA), 21(SCL)
// On an arduino LEONARDO:   2(SDA),  3(SCL), ...
#define OLED_RESET     -1 // Reset pin # (or -1 if sharing Arduino reset pin)
#define SCREEN_ADDRESS 0x3C ///< See datasheet for Address; 0x3D for 128x64, 0x3C for 128x32
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);


const char* ssid = "";//replace this with your wifi access point 
//name
const char* password = ""; //replace with your wifi password
const char* broker = ""; //IP address of broker
const int port = 1883;
const char* mqttUser = "user";
const char* mqttPassword = "user";

WiFiClient espClient;
PubSubClient client(espClient);

void callback(char* topic, byte* payload, unsigned int length) {

  Serial.print("Message received in topic: ");
  Serial.print(topic);
  Serial.print("   length is:");
  Serial.println(length);
// toto = "";
  display.clearDisplay();
  display.setTextSize(1);      // Normal 1:1 pixel scale
  display.setTextColor(SSD1306_WHITE); // Draw white text
  display.setCursor(0, 0);     // Start at top-left corner
  display.print(F("Puissance:"));
  display.cp437(true);
  Serial.print("Data Received From Broker:");
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
    display.write((char)payload[i]);
  }
   display.println(F("W"));
  Serial.println();
  Serial.println("-----------------------");
  Serial.println();
  
//  display.println(F((char)toto));
  display.display();
}

void setup() {

  Serial.begin(115200);
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F("SSD1306 allocation failed"));
    for(;;); // Don't proceed, loop forever
  }

  WiFi.begin(ssid, password);
  Serial.println("Connecting to WiFi..");
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(100);
    yield();
  }
  Serial.println("Connected to the WiFi network");

  client.setServer(broker, port);
  client.setCallback(callback);

  while (!client.connected()) {
    Serial.println("Connecting to MQTT...");

    if (client.connect("ESP32Client"))
    {

      Serial.println("connected to MQTT broker");

    }
    else
    {

      Serial.print("failed with state ");
      Serial.print(client.state());
      delay(500);

    }
  }

  
  Serial.println("ESP8266 AS SUBSCRIBER");
  Serial.println("Subscribing topic test:");
  client.subscribe("power");//topic name="abc"

}

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

Une fois ces données renseignées, vous pouvez téléverser sur la board. Pensez à selectionner le bon port COM.

Maintenant que tout est ok, vous pouvez ouvrir le terminal du broker pour vérifier que la connexion du nouveau dispositif se met en place (Ici ESP32Client)

En parallèle, vous pouvez regarder le terminal du xKy et voir qu’il se connecte au topic

Normalement au bout d’une minute, vous devriez avoir un message qui apparait

Et si vous regardez l’écran, vous devriez avoir l’information de puissance apparaitre.

Voilà, vous avez maintenant un dispositif qui permet d’afficher la puissance apparente fournie par le Linky

J’espère que cet article pourra vous servir et n’hésitez pas à faire des suggestions sur de futurs évolutions.

Jérôme Ferrari