Tout savoir sur le capteur PZEM-004T - 100A : Mesure de puissance simplifiée avec MicroPython et ESP32

Dans un monde de plus en plus conscient de sa consommation énergétique, comprendre et surveiller notre utilisation d'électricité devient primordial. Que vous soyez un bricoleur passionné, un professionnel de la domotique ou simplement curieux de connaître votre consommation électrique, le capteur PZEM-004T - 100A pourrait bien être la solution que vous cherchez. Découvrons ensemble cet outil polyvalent et comment l'intégrer facilement dans vos projets grâce à MicroPython.

Qu'est-ce que le PZEM-004T - 100A ?

Le PZEM-004T - 100A est un module de mesure électrique complet qui permet de surveiller :

La tension (V)
Le courant (jusqu'à 100A)
La puissance active (W)
L'énergie consommée (kWh)
La fréquence du réseau
Le facteur de puissance

Ce petit capteur abordable (généralement disponible entre 15 et 25€) fonctionne sur les réseaux monophasés et communique via le protocole Modbus RTU à travers une interface UART, le rendant compatible avec la plupart des microcontrôleurs modernes comme Arduino, ESP8266, ESP32, ou Raspberry Pi.

Avantages du PZEM-004T

Précision : Les mesures sont fiables, avec une précision de 0.5% pour le courant et 1% pour la puissance
Installation facile : Se place en série sur votre circuit électrique
Polyvalence : Adapté aussi bien aux applications domestiques qu'industrielles
Communicatif : S'intègre parfaitement dans des systèmes de domotique ou de monitoring
Économique : Excellent rapport qualité-prix pour les capacités offertes

Mise en œuvre avec MicroPython

Une des forces du PZEM-004T est sa facilité d'intégration, notamment avec MicroPython, un langage de plus en plus populaire pour les objets connectés. Voici comment mettre en place un système complet de mesure de puissance en quelques étapes.

Matériel nécessaire

Un capteur PZEM-004T - 100A
Un microcontrôleur compatible MicroPython (ESP32, ESP8266, etc.)
Quelques fils de connexion
Une alimentation 5V

Connexion du capteur

Instructions de câblage pour intégrer le PZEM-004T dans un projet de surveillance de la consommation électrique. Le diagramme de blocs explique le fonctionnement interne du module.

Le PZEM-004T se connecte facilement à votre microcontrôleur :

TX du PZEM → RX de votre microcontrôleur
RX du PZEM → TX de votre microcontrôleur
GND → GND
VCC → 5V

Attention : N'oubliez pas que le côté mesure de puissance du PZEM-004T doit être connecté en série avec la charge que vous souhaitez mesurer. Assurez-vous de respecter les consignes de sécurité électrique lors de l'installation.

Le code MicroPython

Voici un code MicroPython complet permettant d'exploiter toutes les fonctionnalités du PZEM-004T :

import time
from machine import UART

class PZEM004T:
    def __init__(self, uart_id=2, tx_pin=17, rx_pin=16, addr=0xF8):
        self.uart = UART(uart_id, baudrate=9600, tx=tx_pin, rx=rx_pin)
        self.addr = addr

    def _crc16(self, data):
        crc = 0xFFFF
        for byte in data:
            crc ^= byte
            for _ in range(8):
                if crc & 0x0001:
                    crc >>= 1
                    crc ^= 0xA001
                else:
                    crc >>= 1
        return crc.to_bytes(2, 'little')

    def _build_request(self, cmd, raddr=None, rlen=None):
        if raddr is None:
            req = bytes([self.addr, cmd])
        else:
            req = bytes([self.addr, cmd, raddr >> 8, raddr & 0xFF, rlen >> 8, rlen & 0xFF])
        return req + self._crc16(req)

    def _read_response(self, response_len):
        response = self.uart.read(response_len)
        if response is None or len(response) < response_len:
            return None
        return response

    def read_voltage(self):
        # Registre 0x0000 pour la tension
        self.uart.write(self._build_request(0x04, 0x0000, 0x0001))
        time.sleep(0.2)
        response = self._read_response(7)
        if response and response[0] == self.addr and response[1] == 0x04 and response[2] == 2:
            voltage = int.from_bytes(response[3:5], 'big') / 10.0
            return voltage
        return None

    def read_current(self):
        # Registre 0x0001 pour le courant
        self.uart.write(self._build_request(0x04, 0x0001, 0x0001))
        time.sleep(0.2)
        response = self._read_response(7)
        if response and response[0] == self.addr and response[1] == 0x04 and response[2] == 2:
            current = int.from_bytes(response[3:5], 'big') / 1000.0
            return current
        return None

    def read_power(self):
        # Registre 0x0003 pour la puissance
        self.uart.write(self._build_request(0x04, 0x0003, 0x0001))
        time.sleep(0.2)
        response = self._read_response(7)
        if response and response[0] == self.addr and response[1] == 0x04 and response[2] == 2:
            power = int.from_bytes(response[3:5], 'big') / 10.0
            return power
        return None

    def read_energy(self):
        # Registre 0x0005 pour l'énergie
        self.uart.write(self._build_request(0x04, 0x0005, 0x0001))
        time.sleep(0.2)
        response = self._read_response(7)
        if response and response[0] == self.addr and response[1] == 0x04 and response[2] == 2:
            energy = int.from_bytes(response[3:5], 'big')
            return energy
        return None

    def read_all(self):
        voltage = self.read_voltage()
        current = self.read_current()
        power = self.read_power()
        energy = self.read_energy()
        return voltage, current, power, energy

# Exemple d'utilisation
def main():
    # Créez une instance de PZEM004T avec les broches UART appropriées
    # Ajustez uart_id, tx_pin, rx_pin selon votre configuration
    pzem = PZEM004T(uart_id=2, tx_pin=17, rx_pin=16)
    
    while True:
        voltage, current, power, energy = pzem.read_all()
        
        print("Tension: {:.1f}V".format(voltage if voltage is not None else 0))
        print("Courant: {:.3f}A".format(current if current is not None else 0))
        print("Puissance: {:.1f}W".format(power if power is not None else 0))
        print("Énergie: {}Wh".format(energy if energy is not None else 0))
        print("------------------------")
        
        time.sleep(5)

if __name__ == "__main__":
    main()

Comprendre le code

Ce code MicroPython élégant et efficace crée une classe dédiée au PZEM-004T qui vous permet d'accéder facilement à toutes les fonctionnalités du capteur :

Initialisation : La classe se configure avec les paramètres UART spécifiques à votre montage
Calcul CRC16 : Assure l'intégrité des communications avec le module
Construction des requêtes : Formate les demandes selon le protocole Modbus RTU
Lectures spécifiques : Des méthodes dédiées pour lire chaque valeur (tension, courant, puissance, énergie)
Lecture complète : Une méthode pratique pour obtenir toutes les mesures en une seule fois

Applications pratiques

Une fois votre PZEM-004T connecté et programmé, les possibilités sont nombreuses :

1. Monitoring de consommation domestique

Surveillez la consommation de vos appareils électroménagers pour identifier ceux qui consomment le plus. Vous pourriez être surpris de découvrir que certains appareils en veille consomment considérablement plus que d'autres en fonctionnement !

2. Intégration domotique

Connectez votre PZEM-004T à un système domotique comme Home Assistant, OpenHAB ou Jeedom pour intégrer vos données de consommation électrique à votre tableau de bord et créer des automatisations basées sur la consommation.

# Exemple d'envoi de données à un serveur MQTT pour Home Assistant
def send_to_home_assistant(pzem, mqtt_client):
    voltage, current, power, energy = pzem.read_all()
    
    mqtt_client.publish("home/energy/voltage", str(voltage))
    mqtt_client.publish("home/energy/current", str(current))
    mqtt_client.publish("home/energy/power", str(power))
    mqtt_client.publish("home/energy/energy", str(energy))

3. Optimisation énergétique industrielle

Dans un contexte industriel, le PZEM-004T peut aider à identifier les périodes de surconsommation, optimiser les cycles de production, et anticiper les problèmes de maintenance en détectant des variations anormales de consommation.

4. Projets éducatifs et scientifiques

Le module est parfait pour des projets éducatifs sur les énergies, la consommation électrique ou même pour l'apprentissage de la programmation et des protocoles de communication.

Conseils d'experts

Pour tirer le meilleur parti de votre PZEM-004T, voici quelques conseils :

Calibration : Bien que le capteur soit précis, comparez ses mesures avec un multimètre professionnel pour vous assurer de sa précision dans votre installation
Sécurité avant tout : N'oubliez pas que vous travaillez avec de l'électricité. Assurez-vous de couper l'alimentation avant toute manipulation
Stockage des données : Ajoutez une carte SD ou une connexion WiFi pour enregistrer l'historique de vos mesures et créer des graphiques d'évolution
Notifications : Configurez des alertes en cas de dépassement de seuils prédéfinis
Mise à jour du firmware : Certaines versions du PZEM-004T permettent des mises à jour du firmware, renseignez-vous auprès du fabricant

Conclusion

Le PZEM-004T - 100A est un capteur remarquablement polyvalent qui, couplé à la puissance et la simplicité de MicroPython, ouvre la voie à d'innombrables projets de mesure et d'optimisation électrique. Que vous soyez un maker, un professionnel ou simplement un utilisateur soucieux de sa consommation, ce petit module abordable pourrait bien devenir un outil indispensable dans votre boîte à outils électronique.

Il illustre parfaitement comment des technologies accessibles peuvent nous aider à mieux comprendre et gérer notre consommation d'énergie, un enjeu crucial à l'heure où l'efficacité énergétique devient une priorité mondiale.

Alors, prêt à mesurer, analyser et optimiser votre consommation électrique avec le PZEM-004T ?

Code optimisé:
import time
from machine import UART

REGISTER = {
   "voltage":         [ 0x0000, 0.1, "V" ],
   "current_low": [ 0x0001,0.001 , "A" ],
   #"current_high": [ 0x0002,0.001 , "A" ],
   "power_low":    [ 0x0003, 0.1 , "W" ],
   #"power_high":    [ 0x0004, 0.1 , "W" ],
   "energy_low":   [ 0x0005,1 , "Wh" ],
   #"energy_high":   [ 0x0006,1 , "Wh" ],
   "frequency":      [ 0x0007,0.1 , "Hz" ],
   "power_factor": [ 0x0008, 0.01 , "" ]
}

class PZEM004T:
      def __init__(self, uart_id=2, tx_pin=17, rx_pin=16, addr=0xF8):
            self.uart = UART(uart_id, baudrate=9600, tx=tx_pin, rx=rx_pin)
            self.addr = addr

      def _crc16(self, data):
            crc = 0xFFFF
            for byte in data:
                  crc ^= byte
                  for _ in range(8):
                        if crc & 0x0001:
                              crc >>= 1
                              crc ^= 0xA001
                        else:
                              crc >>= 1
            return crc.to_bytes(2, 'little')

      def _build_request(self, cmd, raddr=None, rlen=None):
            if raddr is None:
                  req = bytes([self.addr, cmd])
            else:
                  req = bytes([self.addr, cmd, raddr >> 8, raddr & 0xFF, rlen >> 8, rlen & 0xFF])
            return req + self._crc16(req)

      def _read_response(self, response_len):
            response = self.uart.read(response_len)
            if response is None or len(response) < response_len:
                  return None
            return response

      def read_sensor(self,name):
            adresse = REGISTER[name][0]
            precision = REGISTER[name][1]
            unity =   REGISTER[name][2]
            self.uart.write(self._build_request(0x04, adresse, 0x0001))
            time.sleep(0.2)
            response = self._read_response(7)
            if response and response[0] == self.addr and response[1] == 0x04 and response[2] == 2:
                  sensor = int.from_bytes(response[3:5], 'big') * precision
                  return sensor
            return None

      def read_all(self):
            tab = []
            for c in REGISTER:
                  value = self.read_sensor(c)
                  unit = REGISTER[c][2]
                  tab.append(str(value)+unit)
            return tab

# Exemple d'utilisation
def main():
      # Créez une instance de PZEM004T avec les broches UART appropriées
      # Ajustez uart_id, tx_pin, rx_pin selon votre configuration
      pzem = PZEM004T(uart_id=2, tx_pin=15, rx_pin=2)

      while True:
            tab = pzem.read_all()

            for c in tab :
                  print(c)
            print("-"*20)
            #pzem.read_power()

            time.sleep(5)

if __name__ == "__main__":
      main()

Détails: Écrit par : Richard GAUTHIER; Création : 22 Mars 2025; Mis à jour : 30 Mars 2025; Clics : 20

Vidéos YouTube