Realizzare un Power Meter con ESP8266 e programmarlo per interagire con Home Assistant

Un Power Meter è uno strumento posizionato a valle del contatore elettrico che permette di monitorare, gestire e conoscere i consumi elettrici. Esistono diverse versioni di power meter in commercio, ma nel video di oggi vogliamo spiegarvi come realizzarne uno da solo, investendo poco tempo.

 

Progetto

Il Power Meter che andiamo a creare con una ESP8266 è pensato come progetto DIY, quindi un progetto hobbistico e non professionale, pertanto le letture potrebbero essere simili ma non identiche a quelle reali.



Il device avrà il compito di rilevare i consumi ed inviarli tramite MQTT al mini pc con Home Assistant, integrandolo adeguatamente all’interno della plancia di quest’ultimo. Lo scopo è generare anche un grafico storico in cui leggere i valori nel lungo periodo.

Lista acquisti su Amazon:

Lista acquisti su Aliexpress:

Componenti

Il cuore pulsante del progetto è una Wemos D1 Mini, quindi una ESP8266 di piccole dimensioni. Alla Wemos è collegato un sensore di corrente non invasivo con clip apribile YHDC SCT-013-000, in grado di rilevare fino a 100 Ampere.

Per gestire correttamente i collegamenti e regalare le letture e la comunicazione, nonché l’alimentazione del sensore, abbiamo due resistori da 10k Ω, uno da 33 Ω ed un condensatore da 10μF. L’alimentazione del sistema è affidato ad un trasformatore Hi-Link HLK-5M05 da 230V in CA a 5V in CC. Abbiamo anche due terminali da 5mm, uno per collegare la Fase ed il Neutro per l’alimentazione, l’altro per collegare il sensore. Per garantire anche un minimo di sicurezza, abbiamo anche installato un fusibile sulla linea della Fase. Per garantire un buon risultato abbiamo realizzato anche un PCB. Potete scaricare il file Gerber del progetto a questo LINK.

Collegamenti

I collegamenti per realizzare il Power Meter sono riportati in basso. Il sensore è collegato al pin analogico A0 della Wemos D1 Mini, mentre l’intero sistema è alimentato a 5V forniti dal Hi-Link HLK-5M05. Abbiamo anche installato un pulsante di Reset collegandolo dal pin RST e GND della scheda.

Il terminale posto in alto, nello schema, permette di collegare la Linea ed il Neutro della 230V di casa al HLK-5M05 di Hi-Link, trasformando la CA in DC a 5V. Il secondo terminale permette di collegare il sensore al PCB, leggendo i dati in arrivo. Come leggete, tutto il sistema è alimentato a 5V.



Abbiamo saldato tutto sul PCB e questo è il risultato finale.

Infine, abbiamo realizzato anche una cover con la stampante 3D dove alloggiare il PCB. Trovare a questo LINK i file STL.

Codice

Andiamo a lavorare sul codice [LINK], iniziando come sempre dalle librerie che dobbiamo adoperare:

#include "Arduino.h"
#include "ESP8266WiFi.h"
#include "PubSubClient.h"
#include "NTPClient.h"
#include "WiFiUdp.h"

Queste librerie ci consentono di collegarci alla rete Wi-Fi di casa ottenendo un indirizzo IP, per poi collegarci al broker MQTT di Home Assistant, inviando i dati che poi elaboreremo.  Per gestire il sensore di corrente abbiamo necessità della libreria EmoLib.h che adoperiamo per creare l’oggetto emon1.

#include "EmonLib.h"
EnergyMonitor emon1;

Successivamente inseriamo i parametri di rete, tra i quali SSID della rete Wi-Fi e la relativa password, senza dimenticarci di inserire anche l’indirizzo IP del broker MQTT (l’indirizzo del PC su cui è installato Home Assistant), la porta, l’username e la password, tutte informazioni che trovare sul Home Assistant se avete attivato l’add-on Moquitto broker.

const char* ssid = "SSID";
const char* password = "password";
const char* mqtt_server = "1xx.xxx.xxx.xxx";
const int mqtt_server_port = 1883;
const char* mqttUser = "xxxxxxxxxxxxx";
const char* mqttPassword = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

Dichiariamo prima gli oggetti utili per il programma per connettersi alla rete Wi-Fi, sincronizzarsi con il server MQTT e scambiarsi dati, poi le variabili per il timer non stoppante e per le misurazioni che andremo a inviare.

WiFiClient wifiClient;
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);
PubSubClient mqttClient(wifiClient);

unsigned long time_now = 0;

float power, Irms, consumo;

Nel VOID SETUP inizializziamo il monitor seriale, ci colleghiamo alla rete Wi-Fi, ottenendo un indirizzo IP, settiamo il server MQTT e indichiamo il PIN Analogico a cui è collegato il sensore e calibriamolo per le letture.

Serial.begin(115200);
   WiFi.mode(WIFI_STA);
   WiFi.begin(ssid, password);


 
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.println("Connessione al WiFi..");
  }
  Serial.print("Connesso alla rete WiFi");
  Serial.println(WiFi.localIP());
  
  mqttClient.setServer(mqtt_server, mqtt_server_port);

  emon1.current(A0, 10.0);



Passiamo ora al VOID LOOP, iniziando a connetterci al server MQTT.

   if (!mqttClient.connected()) {
     connect();
   }
   mqttClient.loop();
   timeClient.update();

Viene richiamata la funziona connect(), la quale verifica se la connessione è avvenuta o meno, tentando di connettersi al server MQTT ogni 5 secondi inserendo le credenziali di accesso che abbiamo dichiarato in cima al nostro codice. Che la connessione avvenga o meno, sul monitor seriale ci verrà indicato.

void connect() {
   while (!mqttClient.connected()) {
     Serial.print("Attendere connessione MQTT...");
     String mqttClientId = "";
     if (mqttClient.connect(mqttClientId.c_str(), mqttUser, mqttPassword)) {
       Serial.println("connesso");
     } else {
       Serial.print("fallita, rc=");
       Serial.print(mqttClient.state());
      Serial.println(" tentativo tra 5 secondi");
       delay(5000);
     }
   }
 }

Tornado al VOID LOOP, avviamo il timer no stoppante, all’interno del quale rileviamo gli Ampere (Irms), calcoliamo la Potenza (W) e i Consumi (kWh), li inviamo al server come stringa, seguendo uno specifico percorso che dobbiamo tenere in considerazione quando andremo a integrare il nostro Power Meter in Home Assistant.

if(millis() > time_now + 3000){
Irms = emon1.calcIrms(1480);  // Calcola corrente
mqttClient.publish("sensor/amp", String(Irms).c_str());

power = Irms*230.00*0.8;  // Calcola Watt
mqttClient.publish("sensor/power", String(power).c_str());

consumo = (power/1000)*1;  // Calcola kWh
mqttClient.publish("sensor/consumo", String(consumo).c_str());

Serial.print(Irms);
Serial.println("A");
Serial.print(power);
Serial.println("Watt");
Serial.print(consumo);
Serial.println("kWh");

  time_now = millis(); 
  }

Home Assistant

Concluso il codice, passiamo alla integrazione in Home Assistant. Apriamo il File editor e muoviamoci per modificare il file configuration.yaml. Andiamo a copiare ed incollare quanto segue:

mqtt:
    sensor:
        - name: "Corrente"
          state_topic: "sensor/amp"
          qos: 0
          unit_of_measurement: "A"
          icon: "mdi:current-ac"
          device_class: energy
          
        - name: "Potenza"
          state_topic: "sensor/power"
          qos: 0
          unit_of_measurement: "W"
          icon: "mdi:flash"
          device_class: energy
          
        - name: "Consumo"
          state_topic: "sensor/consumo"
          qos: 0
          unit_of_measurement: "kWh"
          icon: "mdi:meter-electric"
          device_class: energy
          state_class: total

Quando creiamo un sensore collegato al server MQTT dobbiamo necessariamente andare ad indicare il name che deve essere univoco, lo state_topic che indica l’argomento per la ricezione dei dati (lo abbiamo indicato nel VOID LOOP del Power Meter), la device_class indicante il tipo di sensore ed essendo energetico mettiamo energy, mentre solo per il Consumo mettiamo lo state_class in total, indicando una misurazione soggetta a aumenti o diminuzioni. Le altre indicazioni servono ad indicare l’unità di misura (unit_of_measurement), l’icona da associare(icon) e la qualità del servizio(qos). Terminata la modifica del file configuration.yaml, andiamo su Strumenti per sviluppatori, verifichiamo le modifiche e riavviamo Home Assistant.



Per implementare nella Plancia le misurazioni del nostro Power Meter possiamo vi lasciamo il codice da inserire manualmente nell’editor della scheda.

type: entities
entities:
  - entity: sensor.corrente
    icon: mdi:current-ac
  - entity: sensor.potenza
    icon: mdi:flash
    secondary_info: none
  - entity: sensor.consumo
    icon: mdi:meter-electric
title: Power Meter
state_color: true

Il prossimo passo sarà creare un grafico storico del consumo, per monitorare il totale dei consumi nel lungo periodo. Sempre dalla Plancia, aggiungiamo una scheda e inseriamo il seguente codice manualmente.

chart_type: line
period: 5minute
type: statistics-graph
title: Consumi
entities:
- sensor.consumo
stat_types:
- state
hide_legend: false
logarithmic_scale: false

Il grafico che abbiamo creato è lineare, riportante le misurazioni orarie dei Consumi rilevati. Possiamo modificarlo cambiandolo in barre o rilevando periodi di tempo più brevi, che vanno dai 5 minuti alle settimane.