[TUTORIEL] - Gestion électrique


#1

Bonjour à tous

Aujourd’hui je vais vous faire un petit tutoriel pour pouvoir gérer votre réseau électrique.
[–ATTENTION–]
Avant toute chose sachez que pour faire ce tutoriel il vous faut quelques bases d’électricité.
Effectivement il va falloir travailler avec du 220 / 230V.
Vous voila prévenu

Je vous invite à faire un tour sur ce site qui explique très bien un grand nombre d’étapes.
A la fin du tutoriel vous pourrez consulter

  • La tension de votre maison
  • Son intensité
  • La puissance
  • et la consommation

Vous retrouverez des graphiques dans ce genre :

Pour ma part je trouve ça “utile” de pouvoir connaître sa consommation
Commençons :slight_smile:

    • Matériel requis :
  • Un PZEM-004T voilà à quoi ça ressemble
    image
  • Un arduino (Nano pour ma part) mais il est possible d’utiliser un ESP8266 ou un autre arduino. On peut également le faire directement avec le raspberry.
  • Je vous conseil également d’avoir d’une rallonge électrique.
  • Et un consommateur pour faire les tests. (Lampe de chevet, radio-réveil, etc)
    • Branchement du PZEM-004T :

a. -) Pour les branchements je vous invite à aller voir le tuto cité plus haut.
Cependant [–ATTENTION–] le câble à passer dans la tor (la sorte de cercle noir) n’est pas le câble de NEUTRE (BLEU) comme indiqué sur le schéma mais le câble MARRON (PHASE).
Pour ce qui concerne l’alimentation du PZEM-004T j’ai coupé un câble comme celui ci dessous pour avoir ma phase et mon neutre
image
Si vous avez le moindre doute, n’hésitez pas à me demander de l’aide au moment des branchements :wink:

b. -) Pour les branchements sur l’Arduino
Peu d’explications les images suffisent :
image

    • Partie logiciel :

Dans un premier temps je vous invite à faire des tests sur une rallonge électrique.
Croyez moi ça vous évitera de couper, couper et couper encore du câble sur un appareil :joy:
Pour faire le test, vous pouvez commencer par copier ce sketch sur votre arduino, ne changer rien au code si vous avez fait les mêmes branchements que plus haut.

#include <SoftwareSerial.h> // Arduino IDE <1.6.6
#include <PZEM004T.h>

PZEM004T pzem(10,11);  // RX,TX
IPAddress ip(192,168,1,1);

/*
 * PDAControl
 * Documentation PDAControl English:
 * http://pdacontrolen.com/meter-pzem-004t-with-arduino-esp32-esp8266-python-raspberry-pi/
 * Documentacion PDAControl Español:
 * http://pdacontroles.com/medidor-pzem-004t-con-arduino-esp32-esp8266-python-raspberry-pi/
 * Video Tutorial : https://youtu.be/qt32YT_1oH8
 * 
 */

void setup() {
  Serial.begin(9600);
  pzem.setAddress(ip);  
}

void loop() {

  Serial.println("");
   
   float v = pzem.voltage(ip);
  if(v >= 0.0){ Serial.print(v);Serial.print("V; "); }
   
  float i = pzem.current(ip);
  if(i >= 0.0){ Serial.print(i);Serial.print("A; "); }
   
  float p = pzem.power(ip);
  if(p >= 0.0){ Serial.print(p);Serial.print("W; "); }

  float e = pzem.energy(ip);
  if(e >= 0.0){ Serial.print(e);Serial.print("Wh; "); }  

  Serial.println();

}

Une fois le code téléversé, ouvré le moniteur série.
Vous devriez voir apparaître le voltage, l’intensité, la puissance et la consommation
Si ce n’est pas le cas, assurez vous :

  • Qu’il y a bien un appareil de brancher sur votre rallonge !
  • Que le PZEM-004T est bien branché sur le 220V
  • Que la tor est bien au tour du câble de phase
  • Que le VCC, RX, TX et GND est correctement branché.
    • Coucou Gladys :

Si vous voyez tout cela on va passer à l’inclusion du PZEM-004T sur Gladys !
Pour ce faire nous allons devoir connaître le port USB où est connecté l’Arduino afin de créer un Device (Arduino nano oblige)
Nous allons donc nous connecter en ssh au pi et taper la commander suivante :
ls /dev/tty*

Vous devriez voir apparaître ceci
Capture%20lsdev

Maintenant branché votre arduino sur le pi, attendez quelques secondes puis retaper la commande
ls /dev/tty*
Capture%20lsdev
On peut voir qu’il y a un nouveau périphériques de détecté
/dev/ttyUSB0

Désormais on connaît le nom du port usb utilisé.
Nous allons nous rendre sur Gladys, Devices, Mes devices puis créer un device comme celui-ci avec vos informations.

Après cela il faudra créer un nouveau device :

Puis dans ce device, il faudra créer 4 devicetypes :

Retenez bien l’ID des 4 devicetype nous allons en avoir besoin ci-dessous.

Nous allons maintenant téléverser un nouveau code sur l’arduino en remplaçant ID_DE_VOTRE_DEVICETYPE par les votre

 /***************************************************************
  ********* Déclaration des librairies et variables *************
  **************************************************************/
  
#include <PZEM004T.h>                                             // Inclusion de la librairie PZEM004T
#include <ArduinoJson.h>                                          // Inclusion de la librairies ArduinoJson.h

PZEM004T pzem(10,11);                                             // RX et TX connectés sur les pins 10 et 11
IPAddress ip(192,168,1,1);                                        // Permet de créer l'adresse ip du PZEM-004T

struct pzemData {                                                 // Création du type pzemdata pour stocker les mesures
  int id;                                                         // Création d'une variable int "id"
  float valeur;                                                   // Création d'un variable float "valeur"
};

int devicetype_id1 = ID_DE_VOTRE_DEVICETYPE;                      // Id du devicetype "Volts" dans Gladys
int devicetype_id2 = ID_DE_VOTRE_DEVICETYPE;                      // Id du devicetype "Ampères" dans Gladys
int devicetype_id3 = ID_DE_VOTRE_DEVICETYPE;                      // Id du devicetype "Watts" dans Gladys
int devicetype_id4 = ID_DE_VOTRE_DEVICETYPE;                      // Id du devicetype "Watts/Heure" dans Gladys

#define PZEMDATA_JSON_SIZE (JSON_OBJECT_SIZE(3))                  // Variable indiquant la taille du buffer

/***************************************************************
 **************** Début du programme Setup *********************
 **************************************************************/

void setup () {
  Serial.begin(9600);                                             // Ouverture du port série à 9600 bauds
  pzem.setAddress(ip);                                            // Initialisation de l'adresse ip de l'objet pzem
}

/***************************************************************
 **************** Début du programme Loop **********************
 **************************************************************/

void loop ()  {

  delay(1000);                                                    // Délai de 1 seconde entre les 4 mesures

  pzemData dataV;                                                 // Objet pour l'enregistrement de la tension
  pzemData dataA;                                                 // Objet pour l'enregistrement de l'intensité
  pzemData dataW;                                                 // Objet pour l'enregistrement de la puissance
  pzemData dataWh;                                                // Objet pour l'enregistrement de la consommation
  
  float v = pzem.voltage(ip);                                     // Associe la variable float "v" au Voltage
  
  float a = pzem.current(ip);                                     // Associe la variable float "a" au Courant
  
  float w = pzem.power(ip);                                       // Associe la variable float "w" a la Puissance
  
  float wh = pzem.energy(ip);                                     // Associe la variable float "wh" a la Consommation


/***************************************************************
 ****** Arrêt du programme et renvoie un message d'erreur ******
 ********** si le PZEM-004T ne renvoie aucunes mesure **********
 **************************************************************/

  if (isnan(v) || isnan(a) || isnan(w) || isnan(wh)) {            // Si "v", "a", "w", "wh" ne sont pas des nombres
    Serial.println("Echec de lecture !");                         // alors s'affiche un message d'erreur "Echec de lecture" 
  }
  else {                                                          // Sinon on affiche les messages JSON
    
/**************************************************************** 
 ****************** Message JSON Voltage ************************
 ***************************************************************/
 
    dataV.id = devicetype_id1;                                    // Si l'id de dataV est egale au devicetype Volts
    dataV.valeur = v;                                             // et que la valeur de dataV est egale au Voltage
    serialize(dataV);                                             // alors on converti l'objet dataV 

/**************************************************************** 
 ****************** Message JSON Courant ************************
 ***************************************************************/

    dataA.id = devicetype_id2;                                    // Si l'id de dataA est egale au devicetype Ampères
    dataA.valeur = a;                                             // et que la valeur de dataA est egale au Ampères
    serialize(dataA);                                             // alors on converti l'objet dataA

/**************************************************************** 
 ***************** Message JSON Puissance ***********************
 ***************************************************************/
    
    dataW.id = devicetype_id3;                                    // Si l'id de dataW est egale au devicetype Watts
    dataW.valeur = w;                                             // et que la valeur de dataW est egale au Watts
    serialize(dataW);                                             // alors on converti l'objet dataW

/**************************************************************** 
 ****************** Message JSON Consommation *******************
 ***************************************************************/
    
    dataWh.id = devicetype_id4;                                   // Si l'id de dataWh est egale au devicetype Watts/Heure
    dataWh.valeur = wh;                                           // et que la valeur de dataWh est egale au Watts/Heure
    serialize(dataWh);                                            // alors on converti l'objet dataWh 
  }
}

/**************************************************************** 
 ************ Lancement du programme de conversion **************
 ***************************************************************/

void serialize(pzemData &data)                                
{
  StaticJsonBuffer<PZEMDATA_JSON_SIZE> jsonBuffer;                // Permet de réserver la mémoire nécessaire au tampon
  JsonObject& json_pzem = jsonBuffer.createObject();              // Création d'un objet json_pzem de type JsonObject
                                                                  // Enregistre dans le tampon JsonBuffer le code Json
  json_pzem["devicetype"] = data.id;                              // Si le devicetype de json_pzem = à celui de Gladys
  json_pzem["value"] = data.valeur;                               // et que la valeur = aux bonnes valeurs
  json_pzem.printTo(Serial);                                      // alors on envoie les résultats sur le port série
  Serial.println("");                                             // Permet de séparer les JSON
}

Une fois le code téléversé, connecté votre arduino sur votre raspberry.
Rebooté, aller dans les périphériques et si tout c’est déroulé comme il faut de votre coté vous devriez voir quelques choses comme ça ainsi que les courbes comme en début de tuto

Capture%20pzem%20encore%204

Vous avez désormais moyen de gérer votre consommation électrique.
J’espère que ce tuto vous aura aidé

A très bientôt :slight_smile: