Mesurer la puissance électrique avec Arduino

🎯 À qui s'adresse ce cours ? À toute personne débutante qui souhaite mesurer des grandeurs électriques réelles (tension, courant, puissance, énergie) avec Arduino, sans avoir besoin d'être électricien.

⚠️ Avertissement de sécurité Le PZEM-004T travaille avec le 230V du secteur. C'est dangereux. Ne branchez jamais la partie 230V pendant que vous manipulez les fils. En cas de doute, faites appel à un adulte compétent ou utilisez une multiprise avec interrupteur.

📋 Sommaire

1. À quoi sert le PZEM-004T ?
2. Matériel nécessaire
3. Présentation du module
4. Schéma de câblage
5. Fonctionnement du module
6. Programme Arduino complet
7. Explication détaillée du code
8. Résultat attendu
9. Aller plus loin
10. Mini défis pratiques

1. 🔌 À quoi sert le PZEM-004T ?

Une analogie pour commencer

Imaginez un compteur électrique comme celui de votre maison. Il mesure combien d'électricité vous consommez. Le PZEM-004T, c'est exactement la même chose, mais en miniature, et connecté à votre Arduino.

Ce qu'il mesure

Le PZEM-004T est capable de mesurer 5 grandeurs électriques en temps réel :

Exemples d'applications concrètes

• 📊 Surveiller la consommation d'un appareil électroménager
• 💡 Savoir combien coûte votre lampe de bureau par heure
• 🔋 Contrôler un système solaire
• 🏭 Monitorer une machine dans un atelier
• 🏠 Créer votre propre compteur électrique connecté

2. 🛒 Matériel nécessaire

💡 Conseil d'achat : Vérifiez bien que vous achetez la version 3.0 du PZEM-004T. Il existe plusieurs versions (v1, v2, v3). La v3.0 utilise le protocole UART/Modbus, ce qui la rend beaucoup plus simple à utiliser avec Arduino.

3. 🔍 Présentation du module

À quoi ressemble le PZEM-004T ?

Le module PZEM-004T se présente sous forme d'un petit circuit imprimé avec :

Les deux parties du module

Le PZEM-004T est divisé en deux zones bien distinctes :

🔴 Zone haute tension (230V) — NE PAS TOUCHER en fonctionnement

• L → Phase (fil marron ou rouge)
• N → Neutre (fil bleu)
• Le fil 230V passe aussi dans le tore (l'anneau en ferrite) pour mesurer le courant

🟢 Zone basse tension (5V) — Communication avec Arduino

• 5V → Alimentation du module
• GND → Masse commune
• TX → Transmission de données vers Arduino
• RX → Réception de données depuis Arduino

4. 🔧 Schéma de câblage

Étape 1 : Câblage basse tension (Arduino ↔ PZEM)

Commencez toujours par cette partie avant de toucher au 230V.

⚠️ Attention au croisement TX/RX ! C'est l'erreur la plus fréquente des débutants :

• Le TX du PZEM se branche sur le RX de l'Arduino (pin 10)
• Le RX du PZEM se branche sur le TX de l'Arduino (pin 11)

TX envoie → RX reçoit : ils doivent toujours être croisés.

Résumé des connexions basse tension

Étape 2 : Câblage haute tension (230V) — ⚠️ DANGER

🛑 Lisez entièrement cette section avant de toucher quoi que ce soit.

En pratique avec une multiprise :

1. Débranchez tout du secteur
2. Le fil phase de l'entrée va sur L entrée du PZEM
3. Le fil neutre de l'entrée va sur N entrée du PZEM
4. La sortie du PZEM va vers l'appareil à mesurer
5. Le fil 230V doit passer dans le tore (anneau) pour la mesure de courant

💡 Astuce : La plupart des modules PZEM-004T vendus sur internet viennent avec le tore séparé. Le fil 230V doit passer à travers le trou du tore. Faites-y passer le fil de phase (L) entre 1 et 3 fois.

5. ⚙️ Fonctionnement du module

Comment le PZEM-004T communique avec Arduino ?

Le PZEM-004T utilise le protocole UART (Universal Asynchronous Receiver Transmitter).

Une analogie simple

Imaginez deux personnes qui s'envoient des SMS :

• L'Arduino envoie un SMS au PZEM : "Donne-moi les mesures"
• Le PZEM répond avec un SMS contenant toutes les valeurs

C'est exactement ce que fait le protocole UART. Les données partent bit par bit, comme des lettres dans un message.

Le protocole Modbus RTU

La version 3.0 utilise le protocole Modbus RTU. Ce protocole est très utilisé dans l'industrie pour faire communiquer des capteurs.

Voici ce qui se passe en coulisses :

Arduino                          PZEM-004T
   │                                 │
   │  "Requête Modbus"               │
   │ ──────────────────────────────► │
   │  [01][04][00][00][00][0A][...] │
   │                                 │
   │         "Réponse"               │
   │ ◄────────────────────────────── │
   │  [01][04][14][09][...][...]    │
   │                                 │
   ▼                                 ▼
Arduino décode les octets
et affiche les valeurs

💡 Bonne nouvelle : vous n'avez pas besoin de comprendre le Modbus en détail. La bibliothèque PZEM004Tv30 s'occupe de tout ça pour vous !

La bibliothèque PZEM004Tv30

Cette bibliothèque fait le travail difficile à votre place :

• Elle envoie les bonnes requêtes au module
• Elle reçoit les réponses
• Elle décode les octets en valeurs lisibles
• Elle vous donne directement la tension, le courant, etc.

6. 💻 Programme Arduino complet

Installation de la bibliothèque

Avant d'écrire le code, installez la bibliothèque :

1. Ouvrez l'IDE Arduino
2. Allez dans Outils → Gérer les bibliothèques
3. Recherchez "PZEM004Tv30"
4. Installez la bibliothèque de Maxim Karpov

Programme de base — Affichage des mesures

// ============================================================
// Cours Arduino — Module PZEM-004T
// Affichage des mesures électriques dans le Moniteur Série
// ============================================================

// On inclut les bibliothèques nécessaires
#include <PZEM004Tv30.h>    // Bibliothèque pour le PZEM-004T v3.0
#include <SoftwareSerial.h> // Permet d'utiliser d'autres broches comme port série

// --- Définition des broches de communication ---
// On utilise les broches 10 et 11 comme port série "logiciel"
// car le port série matériel (0 et 1) est utilisé par le moniteur
#define PZEM_RX_PIN 10  // La broche 10 reçoit les données du PZEM (TX du PZEM)
#define PZEM_TX_PIN 11  // La broche 11 envoie les données au PZEM (RX du PZEM)

// --- Création du port série logiciel ---
// On crée un "canal de communication" entre Arduino et le PZEM
SoftwareSerial pzemSerial(PZEM_RX_PIN, PZEM_TX_PIN);

// --- Création de l'objet PZEM ---
// C'est cet objet qui va gérer toute la communication avec le module
PZEM004Tv30 pzem(pzemSerial);

// ============================================================
// SETUP — S'exécute une seule fois au démarrage
// ============================================================
void setup() {
  // On démarre la communication avec le Moniteur Série (pour afficher les résultats)
  Serial.begin(9600);
  
  // On affiche un message de bienvenue
  Serial.println("=== Mesureur de puissance PZEM-004T ===");
  Serial.println("Démarrage des mesures...");
  Serial.println("---------------------------------------");
}

// ============================================================
// LOOP — S'exécute en boucle indéfiniment
// ============================================================
void loop() {
  
  // --- Lecture de la tension ---
  // La tension s'exprime en Volts (V)
  // En Europe, on attend environ 230V
  float tension = pzem.voltage();
  
  // --- Lecture du courant ---
  // Le courant s'exprime en Ampères (A)
  float courant = pzem.current();
  
  // --- Lecture de la puissance ---
  // La puissance s'exprime en Watts (W)
  // C'est ce que consomme vraiment votre appareil
  float puissance = pzem.power();
  
  // --- Lecture de l'énergie cumulée ---
  // L'énergie s'exprime en Watt-heure (Wh)
  // C'est le total depuis la dernière remise à zéro
  float energie = pzem.energy();
  
  // --- Lecture de la fréquence ---
  // La fréquence s'exprime en Hertz (Hz)
  // En Europe : 50 Hz
  float frequence = pzem.frequency();
  
  // --- Lecture du facteur de puissance ---
  // Sans unité, entre 0 et 1
  // 1.0 = appareil purement résistif (radiateur, ampoule)
  // < 1  = appareil inductif (moteur, transformateur)
  float facteurPuissance = pzem.pf();
  
  // --- Vérification des valeurs ---
  // Si une lecture échoue, la bibliothèque renvoie "NaN" (Not a Number)
  // On vérifie que les mesures sont valides avant d'afficher
  if (isnan(tension)) {
    // Si la tension est invalide, il y a probablement un problème de câblage
    Serial.println("ERREUR : Impossible de lire le PZEM !");
    Serial.println("Vérifiez le câblage TX/RX et l'alimentation 5V.");
  } else {
    // --- Affichage de toutes les mesures ---
    Serial.println("--- Nouvelles mesures ---");
    
    // Affichage de la tension avec 1 décimale
    Serial.print("Tension       : ");
    Serial.print(tension, 1);      // 1 chiffre après la virgule
    Serial.println(" V");
    
    // Affichage du courant avec 3 décimales (pour voir les petites valeurs)
    Serial.print("Courant       : ");
    Serial.print(courant, 3);      // 3 chiffres après la virgule
    Serial.println(" A");
    
    // Affichage de la puissance avec 1 décimale
    Serial.print("Puissance     : ");
    Serial.print(puissance, 1);
    Serial.println(" W");
    
    // Affichage de l'énergie avec 3 décimales
    Serial.print("Energie       : ");
    Serial.print(energie, 3);
    Serial.println(" Wh");
    
    // Affichage de la fréquence avec 1 décimale
    Serial.print("Fréquence     : ");
    Serial.print(frequence, 1);
    Serial.println(" Hz");
    
    // Affichage du facteur de puissance avec 2 décimales
    Serial.print("Facteur puis. : ");
    Serial.print(facteurPuissance, 2);
    Serial.println("");
    
    // --- Calcul bonus : estimation du coût ---
    // Prix moyen du kWh en France : environ 0.25 €
    float prixKwh = 0.25;
    // Coût si l'appareil tournait 1 heure à cette puissance
    float coutHeure = (puissance / 1000.0) * prixKwh;
    
    Serial.print("Coût/heure    : ");
    Serial.print(coutHeure * 100, 2);  // En centimes
    Serial.println(" centimes");
  }
  
  // Ligne séparatrice pour la lisibilité
  Serial.println("-----------------------------------");
  
  // On attend 2 secondes avant la prochaine mesure
  // (ne pas descendre en dessous de 1 seconde)
  delay(2000);
}

7. 📖 Explication détaillée du code

Section 1 : Les bibliothèques

#include <PZEM004Tv30.h>
#include <SoftwareSerial.h>

Pourquoi deux bibliothèques ?

• SoftwareSerial.h : Arduino Uno n'a qu'un seul port série matériel (broches 0 et 1). Ce port est déjà utilisé pour communiquer avec votre ordinateur (Moniteur Série). SoftwareSerial crée un deuxième port série en logiciel sur n'importe quelles autres broches.
• PZEM004Tv30.h : C'est la bibliothèque qui sait "parler" au PZEM. Elle connaît le protocole Modbus et traduit les réponses en valeurs lisibles.

Section 2 : La création de l'objet PZEM

SoftwareSerial pzemSerial(PZEM_RX_PIN, PZEM_TX_PIN);
PZEM004Tv30 pzem(pzemSerial);

Pensez à ça comme la création d'un téléphone (pzemSerial) puis l'ajout d'un interprète (pzem) qui sait parler la langue du PZEM.

Section 3 : La lecture des valeurs

float tension = pzem.voltage();

Le mot float signifie nombre décimal (avec des chiffres après la virgule). On utilise float car la tension peut valoir 229.8 ou 231.4 par exemple.

Chaque fonction retourne une valeur :

Section 4 : La vérification NaN

if (isnan(tension)) {

NaN signifie "Not a Number" (pas un nombre). Quand le PZEM ne répond pas, les fonctions renvoient NaN. isnan()permet de détecter ce cas et d'afficher un message d'erreur clair au lieu d'afficher des données absurdes.

Section 5 : Le calcul du coût

float coutHeure = (puissance / 1000.0) * prixKwh;

Pourquoi diviser par 1000 ?

• La puissance est en Watts (W)
• Le prix est en kilowatts-heure (kWh)
• 1 kWh = 1000 Wh

Donc : Watts ÷ 1000 = kilowatts

8. ✅ Résultat attendu

Ouvrez le Moniteur Série (Ctrl+Maj+M) à 9600 bauds.

Vous devriez voir :

=== Mesureur de puissance PZEM-004T ===
Démarrage des mesures...
---------------------------------------
--- Nouvelles mesures ---
Tension       : 230.4 V
Courant       : 0.217 A
Puissance     : 48.3 W
Energie       : 0.125 Wh
Fréquence     : 50.0 Hz
Facteur puis. : 0.97
Coût/heure    : 1.21 centimes
-----------------------------------
--- Nouvelles mesures ---
Tension       : 230.1 V
...

Valeurs de référence

9. 🚀 Aller plus loin

Programme avancé : Remise à zéro du compteur d'énergie

// Pour remettre le compteur d'énergie à zéro :
// Ajoutez ce code dans setup() ou sur appui d'un bouton

void resetEnergie() {
  if (pzem.resetEnergy()) {
    Serial.println("✓ Compteur d'énergie remis à zéro !");
  } else {
    Serial.println("✗ Échec de la remise à zéro.");
  }
}

Programme avancé : Alerte de surcharge

// Dans loop(), après avoir lu les valeurs :

float PUISSANCE_MAX = 500.0;  // Seuil d'alerte en Watts

if (puissance > PUISSANCE_MAX) {
  Serial.println("⚠️  ALERTE : Consommation trop élevée !");
  // On pourrait aussi allumer une LED ou activer un buzzer
  digitalWrite(LED_BUILTIN, HIGH);
} else {
  digitalWrite(LED_BUILTIN, LOW);
}

Programme avancé : Utilisation avec Arduino Mega

Si vous utilisez un Arduino Mega, vous pouvez utiliser le port série matériel Serial1 (bien plus fiable que SoftwareSerial) :

// Avec Arduino Mega — Brancher sur les broches 19(RX1) et 18(TX1)
#include <PZEM004Tv30.h>

// On passe Serial1 directement, pas besoin de SoftwareSerial
PZEM004Tv30 pzem(Serial1);

void setup() {
  Serial.begin(9600);   // Pour le Moniteur Série
  Serial1.begin(9600);  // Pour le PZEM
}

Brancher plusieurs PZEM sur le même Arduino

Le protocole Modbus permet de connecter plusieurs modules. Chaque module a une adresse différente (de 1 à 247) :

// Deux modules PZEM avec des adresses différentes
PZEM004Tv30 pzem1(pzemSerial, 0x01);  // Module 1 — adresse 1
PZEM004Tv30 pzem2(pzemSerial, 0x02);  // Module 2 — adresse 2

10. 🎯 Mini défis pratiques

⭐ Défi 1 — Débutant

Modifiez le programme pour afficher les mesures toutes les 5 secondes au lieu de 2 secondes. Observez si les valeurs changent.

⭐⭐ Défi 2 — Intermédiaire

Ajoutez une LED sur la broche 13. Faites clignoter la LED si la puissance dépasse 100 Watts.

Indice : utilisez digitalWrite(13, HIGH) et digitalWrite(13, LOW)

⭐⭐ Défi 3 — Intermédiaire

Calculez et affichez le coût mensuel estimé si l'appareil fonctionnait 24h/24 pendant 30 jours.

Formule : coût mensuel = (puissance_W / 1000) × 24 × 30 × prix_kWh

⭐⭐⭐ Défi 4 — Avancé

Ajoutez un bouton poussoir sur la broche 7. Quand on appuie sur le bouton, le compteur d'énergie se remet à zéro et un message s'affiche dans le Moniteur Série.

⭐⭐⭐ Défi 5 — Expert

Connectez un écran LCD I2C (16×2 caractères) à votre Arduino. Affichez sur la première ligne la tension et le courant, et sur la deuxième ligne la puissance et le facteur de puissance.

🧠 Récapitulatif du cours

💬 Conseil final Commencez toujours par tester le câblage sans brancher le 230V. Vérifiez d'abord que le Moniteur Série s'affiche correctement (même avec des NaN). Ensuite seulement, branchez l'alimentation secteur avec un appareil peu puissant comme une simple ampoule LED.

On teste → On observe → On comprend ! 🚀