Routeur Solaire. Mesure de Puissance avec un ESP32
Version V1 avec relais
Une version V2, disposant d’un Triac pour une injection précise de la surproduction est disponible ici: https://f1atb.fr/realisez-un-routeur-solaire-pour-gerer-la-surproduction/
Mesurer en temps réel la puissance électrique consommée, voire produite par une installation solaire permet une meilleure gestion. Par exemple, en cas d’excédant, dans une installation en autoconsommation, on peut enclencher la fabrication d’eau chaude.
Le montage ci-après:
– mesure la puissance
– fourni la courbe instantanée de la tension et du courant sur une page web
– actionne un relais en cas de production au-dessus de la consommation
– fourni un rapport au système central de domotique (Domoticz) pour l’enregistrement.
L’ESP32 est un microcontrôleur adapté à notre besoin. Il comprend :
– des entrées analogiques pour mesurer des tensions,
– des entrées/sorties numériques pour actionner un relais si besoin,
– une liaison WIFI pour faire du reporting à distance sur une page web ou un système de domotique.
Tableau des Versions
Différentes versions de routeur ont été décrites :
Version | Mesure courant / puissance | Actionneurs | Modulaire | Domoticz | MQTT / Home Assistant | Description |
---|---|---|---|---|---|---|
1 | Sonde Ampèremétrique | Relais | Non | Oui | Non | Routeur Solaire. Mesure de Puissance avec un ESP32 |
2 | Sonde Ampèremétrique | Triac + Relais | Non | Oui | Non | Réalisez un Routeur Solaire pour gérer la surproduction |
3.00_UxI | Sonde Ampèremétrique | Triac + Relais | Oui | Oui | Oui | U x I : Routeur Solaire pour gérer la surproduction photovoltaïque |
3.10 Linky | Linky | Triac + Relais | Oui | Oui | Oui | Réalisez un Routeur Solaire avec un Linky |
Capteur du Courant
![](https://f1atb.fr/wp-content/uploads/2022/05/transfocourant.png)
Pour mesurer le courant, on utilise un capteur de courant dans lequel on fait passer le fil de phase du secteur. En sortie, agissant comme un transformateur, il fourni un courant identique, mais 2000 fois plus faible. Ce courant est envoyé aux bornes d’une résistance et nous allons mesurer la tension générée.
Il existe différents modèles suivant le courant Max que l’on souhaite mesurer. La version 100A est adaptée à un domicile ayant une puissance max délivrée de 12kVA. On la trouve en Chine chez Aliexpress.
Capteur de la tension
![](https://f1atb.fr/wp-content/uploads/2022/06/Transfo.png)
Pour mesurer la tension, on utilise un transformateur bobiné classique abaisseur de tension qui nous isole du secteur. Par exemple un 230v/6v. Il faut un modèle le plus petit possible, on ne prélève aucune puissance. Cela n’est plus très facile à trouver. Un transformateur, dit de sonnette, peut faire l’affaire.
Mesure Courant et Tension
La mesure des 2 tensions représentantes du courant et le la tension secteur se fait par les entrées analogiques de l’ESP32. Ces entrées acceptent une tension entre 0 et 3.3V et numérisent la valeur sur 12 bits, valeurs entre 0 et 4095. Pour s’adapter à la dynamique d’entrée, on crée une référence de tension au milieu de la plage à 1.65V =3.3V/2.
![](https://f1atb.fr/wp-content/uploads/2022/06/Entre_mesure.jpg)
On prélève le 3.3V de l’ESP32 qui en passant par un pont de 2 résistances (R6 et R7) de 4700 ohm connecté à la masse nous fourni au milieu une référence de 1.65V. Pour éviter du bruit de mesure, un condensateur de 470uF (C2) filtre le 3.3V et un autre de 10uF (C1) filtre le point milieu à 1.65V.
Afin de ne pas dépasser les 3.3V crête à crête des signaux à mesurer, ou 1.65V crête, on se fixe une limite de +-1V efficace maximum.
Pour la sonde de courant avec 80A et une résistance de 24 ohm , on arrive à peu près au 1V.
24*80A/2000=0.96V
Chez moi, avec un abonnement de 12KVA, je ne devrai pas dépasser les 60A.
Pour la mesure de tension, il faut mettre un pont de résistances (R4 et R5) pour abaisser le 6V autour de 1V efficace.
Raccordement à l’ESP32
![](https://f1atb.fr/wp-content/uploads/2022/06/Schema_Mesure_Power.jpg)
Le jeu de piste avec ces cartes qui intègrent un ESP32, est de trouver les GPIO disponibles et non utilisés pour la programmation Flash etc.
Dans notre cas, on mesure les tensions suivantes:
– GPIO 35 : la tension de référence à 1.65V en théorie.
– GPIO 33 : la tension représentant le courant à mesurer
– GPIO 32 : la tension en sortie du transformateur
2 LED sur les GPIO 18 et 19 clignotent toutes les 2s. La jaune si on consomme du courant, la verte si on fournit du courant, car nous sommes en surproduction.
2 relais solides sur les GPIO 22 et 23 permettent:
– d’allumer une lumière dans le local commandé par l’interrupteur sur le GPIO 05,
– exciter le relais de puissance de mise en route du chauffe-eau en cas de production importante d’électricité.
Mesure
La mesure des 2 valeurs représentant la tension et le courant prend environ 120uS. En pratique, on prévoit sur une période de 20ms (1/50Hz) de prélever 100 couples de valeurs, ce qui donnera une bonne description de la tension à priori sinusoidale et du courant souvent chahuté par les alimentations à découpage.
![](https://f1atb.fr/wp-content/uploads/2022/06/Formule.jpg)
Pour bien caler dans le temps chaque mesure, on utilise l’horloge en micro seconde de l’ESP32.
Toutes les 2 s, on effectue :
– la mesure des tensions et courants durant 20ms
– le calcul du courant efficace
– le calcul de la tension efficace
– le calcul de la puissance en kVA
– le calcul de la puissance en kW
Un calibrage préalable doit être fait pour définir la constante multiplicative kV dans le programme qui permet la conversion de la tension mesurée en binaire vers la tension réelle. De même pour le courant, la constante kI . Utilisez un voltmètre, une pince ampèremétrique ou votre compteur Linky pour la calibration.
Code
L’ensemble du code est écrit en utilisant l’IDE Arduino. Il est injecté dans un premier temps par la liaison série, puis une fois en place, on peut le modifier si besoin par le WIFI comme décrit ici.
#include <WiFi.h>
#include <ESPmDNS.h>
#include <WiFiUdp.h>
#include <WiFiClient.h>
#include <WebServer.h>
#include <ArduinoOTA.h>
#include <RemoteDebug.h>
const char* ssid = "******";
const char* password = "*******";
RemoteDebug Debug;
unsigned long previousComputeMillis;
unsigned long previousClignoteMillis;
unsigned long previousLightMillis;
bool Clignote = false;
bool LightOn =false;
// Set your Static IP address
IPAddress local_IP(192, 168, 0, 208);
// Set your Gateway IP address
IPAddress gateway(192, 168, 0, 254);
IPAddress subnet(255, 255, 255, 0);
IPAddress primaryDNS(8, 8, 8, 8); //optional
IPAddress secondaryDNS(8, 8, 4, 4); //optional
WebServer server(80);
//PINS
const int AnalogIn0 = 35; // GPIO 35
const int AnalogIn1 = 32; // GPIO 32
const int AnalogIn2 = 33; // GPIO 33
const int RelayLight = 22;
const int RelayWaterHeater = 23;
const int LedYellow = 18;
const int LedGreen = 19;
const int Inter = 5;
int value0;
int value1[100];
int value2[100];
int WIFIbug = 0;
float Uef;
float Ief;
float PVA;
float PW;
float PowerFactor;
float kV = 0.2083;
float kI = 0.0642;
float Wh = 0;
//Client of Domoticz
const char* host = "192.168.0.99";
const int httpPort = 8080;
const int idxPower = 1012;
int Nloop = 0;
int day = -1;
// SERVER
//***********
void handleRoot() {
String S;
Debug.println(F("Client Web"));
S = "<body style='background: linear-gradient(#118,#55b,#118);font-size:150%;' onload='setTimeout(\"location.reload();\",2000);'><h2 style='text-align:center;color:white'>Total Power Consumption</h2>";
S += "<div style='text-align:center;width:96%;margin:auto;''>";
S += "<div style='width:400px;margin:auto;'><table align='center' style='border:3px inset grey;padding:4px;background-color:white;font-size:120%;width:100%;'>";
S += "<tr><td>U :</td><td style='text-align: right;'>" + String(Uef) + "</td></tr>";
S += "<tr><td>I :</td><td style='text-align: right;'>" + String(Ief) + "</td></tr>";
S += "<tr><td>P Watt :</td><td style='text-align: right;'>" + String(PW) + "</td></tr>";
S += "<tr><td>P VA :</td><td style='text-align: right;'>" + String(PVA) + "</td></tr>";
S += "<tr><td>Power Factor : </td><td style='text-align: right;'>" + String(PowerFactor) + "</td></tr>";
S += "<tr><td>kWh :</td><td style='text-align: right;'>" + String(Wh / 1000) + "</td></tr>";
S += "<tr><td>Heure :</td><td style='text-align: right;'>" + String(floor(millis()/ 36000)/100) + "</td></tr>";
S += "</table></div>";
S +="<div style='text-align:center;width:1000px;margin:auto;'>";
S += "<div style='text-align:center;'><h3><span style='color:red;'>U_</span><span style='color:lightgreen;'> I_</span></h3>";
S += "<p><svg height='400' width='1000' style='border:3px inset grey;background-color:white;'>";
S += "<line x1='0' y1='400' x2='0' y2='0' style='stroke:rgb(0,0,0);stroke-width:2' />";
S += "<line x1='0' y1='200' x2='1000' y2='200' style='stroke:rgb(0,0,0);stroke-width:2' />";
int Vmax = 1;
int Imax = 1;
for (int i = 0; i < 100; i++) {
Vmax = max(abs(value1[i]), Vmax);
Imax = max(abs(value2[i]), Imax);
Debug.println(value1[i]);
}
S += "<polyline points='";
for (int i = 0; i < 100; i++) {
int Y = 200 - 200 * value1[i] / Vmax;
int X = 10 * i;
S += String(X) + "," + String(Y) + " ";
}
S += "' style='fill:none;stroke:red;stroke-width:6' />";
S += "<polyline points='";
for (int i = 0; i < 100; i++) {
int Y = 200 - 200 * value2[i] / Imax;
int X = 10 * i;
S += String(X) + "," + String(Y) + " ";
}
S += "' style='fill:none;stroke:green;stroke-width:6' />";
S += "</svg></p></div>";
S += "<div style='width:96%;margin:auto;border:3px inset grey;background-color:#666;height:20px;position:relative;'>";
int X = 0;
int Y = 99 - 99 * PW / 12000;
String C="yellow";
if (PW < 0) {
X = 198 - Y;
Y = 0;
C="green";
}
S += "<div style='position:absolute;top:3px;height:14px;background-color:" +C +";left:" + String(X) + "%;right:" + String(Y) + "%;'></div>";
S += "</div>";
S +="</div>";
S +="<div></body>";
server.send(200, "text/html", S );
}
void handleNotFound() {
Debug.println(F("File Not Found"));
String message = "File Not Found\n\n";
message += "URI: ";
message += server.uri();
message += "\nMethod: ";
message += (server.method() == HTTP_GET) ? "GET" : "POST";
message += "\nArguments: ";
message += server.args();
message += "\n";
for (uint8_t i = 0; i < server.args(); i++) {
message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
}
server.send(404, "text/plain", message);
}
// DOMOTICZ client
//****************
void SendToDomoticz() {
String url;
Nloop = (Nloop + 1) % 10;
if (Nloop == 0 || Nloop == 2) {
// Use WiFiClient class to create TCP connections
WiFiClient client;
if (!client.connect(host, httpPort)) {
Serial.println("connection failed");
return;
}
if (Nloop == 2) {
// We now create a URI for the request
url = "/json.htm?type=command¶m=getServerTime"; //Obtain time from Domoticz server
} else {
// We now create a URI for the request
url = "/json.htm?type=command¶m=udevice&idx=";
url += String(idxPower);
url += "&nvalue=0&svalue=";
url += String(PW);
url += ";";
url += String(Wh);
}
// This will send the request to the server
client.print(String("GET ") + url + " HTTP/1.1\r\n" +
"Host: " + host + "\r\n" +
"Connection: close\r\n\r\n");
unsigned long timeout = millis();
while (client.available() == 0) {
if (millis() - timeout > 5000) {
Serial.println(">>> Client Timeout !");
client.stop();
return;
}
}
// Read all the lines of the reply from server and print them to Serial
while (client.available()) {
String line = client.readStringUntil('\r');
// Serial.print(line);
int p = line.indexOf("ServerTime");
if (p > 0) {
String subline = line.substring(p + 14, p + 32);
p = subline.lastIndexOf("-");
subline = subline.substring(p + 1, p + 3); //day after month
// Serial.print(subline);
int theday = subline.toInt();
if (day != theday) {
day = theday;
Wh = 0; // Rest Watt Heure of the day
// Serial.println("Reset Watt Hour");
}
}
}
// Serial.println();
// Serial.println("closing connection");
}
}
// POWER
//********
void MeasurePower() {
int i;
value0 = analogRead(AnalogIn0);
unsigned long MeasureMillis = millis();
unsigned long T= micros();
while (millis() - MeasureMillis < 21) { //Read values during 20ms
i = (micros() % 20000) / 200;
value1[i] = analogRead(AnalogIn1) - value0;
value2[i] = analogRead(AnalogIn2) - value0;
}
}
void ComputePower() {
float V;
float I;
Uef = 0;
Ief = 0;
PW = 0;
for (int i = 0; i < 100; i++) {
V = kV * float(value1[i]);
Uef += sq(V);
I = kI * float(value2[i]);
Ief += sq(I );
PW += V * I;
}
Uef = sqrt(Uef / 100) ;
Ief = sqrt(Ief / 100) ;
PW = floor(PW / 100);
PVA = floor(Uef * Ief);
PowerFactor = floor(100 * PW / PVA) / 100;
Wh += PW / 360; //Every 10s
}
void Overproduction(){
if (PW <-700){ //switch On water heater
digitalWrite(RelayWaterHeater,HIGH);
}
if (PW>1000){ //Switch Off with hyteresis
digitalWrite(RelayWaterHeater,LOW) ;
}
}
// SETUP
//*******
void setup() {
Serial.begin(115200);
Serial.println("Booting");
// Configures static IP address
if (!WiFi.config(local_IP, gateway, subnet, primaryDNS, secondaryDNS)) {
Serial.println("STA Failed to configure");
}
//WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
while (WiFi.waitForConnectResult() != WL_CONNECTED) {
Debug.println("Connection Failed! Rebooting...");
delay(5000);
ESP.restart();
}
// init remote debug
Debug.begin("ESP32");
initOTA();
Debug.println("Ready");
Debug.print("IP address: ");
Debug.println(WiFi.localIP());
Serial.print("IP address: ");
server.on("/", handleRoot);
server.on("/inline", []() {
server.send(200, "text/plain", "this works as well");
});
server.onNotFound(handleNotFound);
server.begin();
Debug.println("HTTP server started");
previousComputeMillis = millis();
previousClignoteMillis = millis();
pinMode( RelayLight , OUTPUT);
pinMode( RelayWaterHeater , OUTPUT);
pinMode( LedYellow , OUTPUT);
pinMode( LedGreen , OUTPUT);
pinMode( Inter , INPUT_PULLUP);
digitalWrite(RelayLight, LOW);
digitalWrite(RelayWaterHeater, LOW);
digitalWrite(LedYellow, LOW);
digitalWrite(LedGreen, LOW);
}
// LOOP
//******
void loop() {
ArduinoOTA.handle();
Debug.handle();
server.handleClient();
if (millis() - previousComputeMillis >= 2000) {
previousComputeMillis = millis();
MeasurePower();
ComputePower();
Overproduction();
if (WiFi.waitForConnectResult() != WL_CONNECTED) {
Debug.println("Connection Failed! #" +String(WIFIbug));
WIFIbug ++;
if ( WIFIbug >20) {
ESP.restart();
}
} else {
Debug.println("Connection OK! ");
WIFIbug = 0;
}
SendToDomoticz();
Debug.println("Power:"+String(PW));
}
if (millis() - previousClignoteMillis >= 2000) {
Clignote = !Clignote;
if (Clignote) {
previousClignoteMillis = millis() - 1950;
} else {
previousClignoteMillis = millis();
}
if (PW >= 0) {
digitalWrite(LedYellow, Clignote);
digitalWrite(LedGreen, LOW);
} else {
digitalWrite(LedYellow, LOW);
digitalWrite(LedGreen, Clignote);
}
}
//Light
if (digitalRead(Inter)==LOW && (millis()-previousLightMillis) >500) {
LightOn=!LightOn;
digitalWrite(RelayLight,LightOn);
previousLightMillis=millis();
}
if (millis() - previousLightMillis >= 120000) {
LightOn=false;
digitalWrite(RelayLight,LightOn);
previousLightMillis=millis();
}
}
// OTA
//******
void initOTA() {
// Port defaults to 3232
// ArduinoOTA.setPort(3232);
// Hostname defaults to esp3232-[MAC]
ArduinoOTA.setHostname("ESP32-Power");
// No authentication by default
ArduinoOTA.setPassword("admin");
// Password can be set with it's md5 value as well
// MD5(admin) = 21232f297a57a5a743894a0e4a801fc3
// ArduinoOTA.setPasswordHash("21232f297a57a5a743894a0e4a801fc3");
ArduinoOTA
.onStart([]() {
String type;
if (ArduinoOTA.getCommand() == U_FLASH)
type = "sketch";
else // U_SPIFFS
type = "filesystem";
// NOTE: if updating SPIFFS this would be the place to unmount SPIFFS using SPIFFS.end()
Debug.println("Start updating " + type);
})
.onEnd([]() {
Debug.println("\nEnd");
})
.onProgress([](unsigned int progress, unsigned int total) {
Debug.printf("Progress: %u%%\r", (progress / (total / 100)));
})
.onError([](ota_error_t error) {
Debug.printf("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) Debug.println("Auth Failed");
else if (error == OTA_BEGIN_ERROR) Debug.println("Begin Failed");
else if (error == OTA_CONNECT_ERROR) Debug.println("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) Debug.println("Receive Failed");
else if (error == OTA_END_ERROR) Debug.println("End Failed");
});
ArduinoOTA.begin();
}
Page Web
Le code comprend un petit serveur Web qui permet d’afficher sur une page, les différentes mesures ainsi que la tension et le courant durant une période de 20 ms.
![](https://f1atb.fr/wp-content/uploads/2022/10/Conso.png)
Montage
![](https://f1atb.fr/wp-content/uploads/2022/06/IMG20220531133756-768x1024.jpg)
Dans une boite d’électricien on installe :
- La carte ESP32 (AZ-Delivery)
- Une alimentation 5V 1A pour l’ESP32
- Un transformateur basse tension pour mesurer la tension
- 2 Relais solide branché en 3.3V, commandé par l’ESP32
- En face avant en option, un bouton poussoir et 2 LEDs
Raccordé à cette boite, on a la sonde de courant à placer autour du fil de phase du secteur à mesurer.
![](https://f1atb.fr/wp-content/uploads/2022/10/Instal_sonde-1024x566.jpg)
Sécurité
En travaillant sur ce projet en 230V, vous acceptez d’assumer la responsabilité de votre propre sécurité et de prendre toutes les précautions nécessaires pour éviter les accidents électriques.
Articles sur le photovoltaïque
- Routeur Photovoltaïque – Installation rapide du logiciel
- Routeur photovoltaïque piloté via MQTT
- Capteur SmartGateways / Siconia pour routeur photovoltaïque
- Routeur photovoltaïque – Modes de régulation
- Routeur photovoltaïque – Affichage et paramétrage
- Routeur photovoltaïque – Réalisation matérielle
- Réalisation d’un Routeur photovoltaïque Multi-Sources Multi-Modes et Modulaire
- Routeur photovoltaïque – Installation manuelle du logiciel
- Capteur Shelly Em™ – Shelly Pro Em™ pour routeur photovoltaïque
- Exemples Montage Routeur Photovoltaïque F1ATB
- Capteur Enphase – Envoy-S Metered™ pour routeur photovoltaïque
- Routeur photovoltaïque simple à réaliser
- Capteur UxIx2 ou UxIx3 pour routeur photovoltaïque
- Triacs gradateurs pour routeur photovoltaïque
- Capteur Linky pour routeur photovoltaïque
- Capteur UxI pour routeur photovoltaïque
- Programmation de l’ESP32 – Application au routeur Photovoltaïque
- Chauffer votre piscine avec l’excédent d’énergie Photovoltaïque
- U x I : Routeur Solaire pour gérer la surproduction photovoltaïque (DIY)
- Panneaux Photovoltaïques Intégrés Au Bâti (IAB) d’un abri voiture
- Réalisez un Routeur Solaire avec un Linky (DIY)
- Câblage de panneaux Photovoltaïques à des Micro-Onduleurs en Autoconsommation (DIY)
- Démarches Administratives pour le Photovoltaïque
- Affichage à distance consommation ou surproduction électrique
- Réalisez un Routeur Solaire pour gérer la surproduction
- Câblage de panneaux Photovoltaïques à un onduleur en Autoconsommation (DIY)
- Panneaux Photovoltaïques Intégrés Au Bâti (IAB)
- Routeur Solaire. Mesure de Puissance avec un ESP32
bonjour
ça fait quelques temps que j’essaie de programmer ce type de produit non sans mal, merci de l’avoir publié ça va me faciliter grandement la tâche.
petite variante que j’aurais à proposer et de piloter non pas un relais mais un variateur de puissance (dimmer) pour injecter dans le chauffe-eau que le surplus ni plus ni moins, je n’hésiterai pas à le partager si j’arrive à l’intégrer.
encore merci
Bonjour,
Je suis actuellement en train d’étudier la même chose que vous, a savoir, mettre un relais Random permettant d’injecter le surplus dans une ECS. Et de plus, l’ajout d’une sonde de température (PT100 ou TC), pour couper la chauffe a une certaine température (surtout pour l’été). Avez vous avancé sur votre projet?
Merci
La dernière version de mon projet est ici : https://f1atb.fr/index.php/fr/2022/12/03/realisez-un-routeur-solaire-pour-gerer-la-surproduction/
Un grand merci pour le temps passé et pour tout le travail exposé.
Pour pinailler un peu mais en aucun cas une critique de ma part, j’ai été déçu de l’esp32 sur la mesure analogique car la plage de mesure n’est pas linéaire sur la plage 0 / 3.3V . Pour des mesures de puissances, les résultats sont plus fiables pour ma part avec un bon Atmega328 ( Arduino UNO) malgré une précisions plus faible que l ESP
Mais le gros point fort de l’ESP32 c’est de pouvoir tout faire avec sans ajout de trop de composants externes comme un convertisseur NA.
Merci encore, heureux d’avoir découvert ton site
La non linéarité de l’ESP32 autour de OV et 3.3V est connue. Avec le schéma proposé, on est cadré au milieu et on ne va pas chercher le 0V ou le 3.3V suivant la résistance de charge choisie.
Merci pour votre remarque pertinente.
Dans la procédure overproduction le relais n’est activé qu’à partir d’un excédant de 700W. Y-a-t-il une contre indication pour abaisser ce seuil à 300 ou 400W?
On peut l’abaisser. Attention à ne pas transformer le système en oscillateur suivant la consommation. La valeur d’enclenchement doit être supérieure à la valeur de déconnexion du montant de la consommation.
Pour s’adapter aux grosses consommations comme un chauffe-eau et les petites surproductions, je prépare une version 2 avec un triac à la place du relais pour pouvoir délivrer des puissances proportionnelles à la surproduction. J’attend les pièces de chine.
bonjour
j’ai découvert votre site et j’adore le contenu est étonnant et simple je vous remercie de partager tous ces montages et en plus ils sont défaits par un vrai passionné et compétent j’aurais plaisir à vous suivre et partager.
merci encore michaelangelo
salut , super vidéos et super site aussi , mais je ne comprends pas bien l’utilité du transfo 220/6 v , seul l’intensité sous environ 230 v peux suffire a déterminer la puissance absorbée ou produite non ??
cela dit je suis toujours étonné de voir les quantités de choses que l’on peut faire avec les ESP 8266 , les 12 et les 32
encore bravo et merci pour vos travaux
La tension est importante pour comparer sa phase avec celle du courant. C’est le seul moyen pour savoir dans quel sens se fait le transfert de puissance.
Bonjour,
Je recherchais justement à réaliser un wattmetre qui pouvait voir si on était en production ou consommation.
J’avais fait un premier montage avec un pzem-004t mais celui-ci ne donnait pas le sens du courant.
Merci donc d’avoir publier ce projet avec des explications claires.
vraiment merci pour ces explications et pour ce tutoriel
j’ai un soucis quand je televerse le code je ne sais plus cmt continuer
j’essaye de me connecter au serveur mais sans succès
svp je souhaiterais avoir une marche à suivre une fois que le code est telversé
Il faut definir dans le code l’adresse IP qui se trouve dans le groupe d’adresse gérée par votre box Internet et tapez l’adresse dans un navigateur.
comment vous faites pour fixer les coefficients kV et Ki svp?
Vos prenez un voltmètre et corrigé kV en faisant une règle de 3 par rapport à la valeur actuelle.
Pour kI, faite la même chose avec une pince ampèremétrique ou un petit ampèremètre en serie en chargeant le systeme avec un courant acceptable (ex lampe à filament, radiateur). Evitez les alimentations à decoupage de LED.
Bonjour
Merci pour ce très bon document et la qualité des explications
J’ai juste une petite question , après avoir décortiqué le code ; d’où viennent les valeurs KV et KI (0.2063 et 0.642)
Je suppose qu’il s’agit de valeur de calibration ….ou bien ai-je raté quelque chose.
Je mets en oeuvre cet am …
Merci encore pour cet article et bon dimanche
Oui kV et kI sont 2 coefficients de calibration à ajuster suivant votre systeme. La sortie du transfo etc en comparant avec les données d’un ampèremètre/voltmètre.
Bonjour, d’abord superbe travail pour le montage du esp32 jusqu’à présents j’ai bien suivi tout le montage et je pense que ça fonctionne bien, la seule chose qui m’a échappé c’est l’intégration dans Domoticz je n’ai pas encore trouvé comment vous avez pu faire.
pouvez-vous m’expliquer comment faire merci d’avance pour tout?
Daniel
Dans domoticz, il faut un senseur virtuel, récupérer son index et on peut envoyer la commande http://…. qui contient les resultats.
Bonjour Mr Buhart je reviens vers vous au sujet de la création d’un senseur virtuel dans domoticz je pense avoir tout ok mais vous parlez d’envoyer la commande je pense que nous penser à l’indice dans le menu dispositif de domoticz chez moi ça ne marche pas pouvez-vous m’en dire plus?
Regardez la documentation de Domoticz qui détaille la syntaxe des reportings. Dans l’adresse de votre navigateur vous pouvez simuler un reporting http://… Il vous dira en retour s’il y a une erreur. Vérifiez bien l’index.
Bonjour
je termine mon installation solaire pour laquelle j’avais prévu un routeur Solaire Fronius Ohmpilot
au final celui-ci n’est pas compatible àvec mon chauffe-eau stéatite.
Je pratique modestement l’Arduino
votre solution m’intéresse vivement mais j’ai un problème lors de la compilation
j’ai cherché et pas trouvé le fichier ESPmDNS.h sur internet !!
——————————————————–
Erreur de compilation:
Routeur_solaire_ESP8266:2:10: fatal error: ESPmDNS.h: No such file or directory
#include
^~~~~~~~~~~
compilation terminated.
Plusieurs bibliothèque trouvées pour « WiFi.h »
Utilisé : C:\Program Files (x86)\Arduino\libraries\WiFi
Non utilisé : C:\Users\admin\Documents\Arduino\libraries\WiFiEspAT
exit status 1
ESPmDNS.h: No such file or directory
————————————————-
Remarque personnelle:
Avec l’Arduino quand on galère rien que pour gérer les bibliothèques on se demande comment on peut produire un programme fonctionnel aussi complexe
FELICITATIONS
Cordialement
Utilisez vous le version 2 d’Arduino? Elle contient plein d’exemples autour du web/DNS pour ESP32 etc. Essayez les. Je n’ai pas eu de souci de bibliothèque.
comment fait-on pour une installation avec un onduleur tri-phasé ?
Merci pour toutes les infos
Au plaisir
Alex
bjr, je recherche la même chose que vous , cdt
Il faut un montage avec 3 sondes de courant pour faire le bilan global des courants sur les 3 phases.
Bonsoir, et je j’aimerais aussi la même chose. Cordialement Jean
D’ici à quelques jours, je publierai une version d’onduleur qui fonctionne en triphasé.
bonjour
j’attends avec impatience votre routeur 2.0
a très bientôt
😎
Bonjour
je voudrais faire le montage sur un ESP 8266,car j’en nais plusieurs.
mais je ne trouve pas les mêmes sorties que sur ESP 32.
Dans le programme je peut enlevé toute la partie wifi et avoir un afficheur simple pour la puissance de sortie en Wh ???
Merci pour une réponse
Salutations
Le problème avec l’esp8266, c’est qu’il n’a qu’une seule entrée analogique et il en faut 3.
Par contre si vous n’utilisez pas le wifi, vous pouvez utiliser un Arduino Nano ou Uno.
La dynamique d’entrée de l’Arduino en analogique est de 0 à 5v sur 10 bits et non pas 0 à 3.3V sur 12bits.
Bonjour,
Merci pour toutes ces informations qui m’ont bien été utiles pour mettre en place une solution équivalente mais avec en plus la mesure de la production solaire (avec un deuxième capteur de courant).
Concernant la mesure de tension j’ai du utiliser une résistance de 47000 au lieu de 24000 (mini transfo de 6v) car je sortais de la plage de mesure de l’ESP32 (0-2V avec l’atténuation par défaut).
Chez moi la tension est une sinusoïde déformée avec un décalage du courant (cos phi) (pas de production solaire au moment de la mesure).
Voici un lien vers la courbe de tension et des courants (grid en orange et solaire en vert):
http://racko.free.fr/tmp/pvwattmetre1.png
Du coup j’ai une question : d’où vient ce décalage entre le courant et la tension, sachant qu’aucun moteur ne tourne au moment de la mesure, seulement des ordinateurs et des radiateurs ?
Merci.
La forme non sinusoïdal et décalée du courant est due à des alimentations à découpage : ordinateurs, chargeurs de téléphone etc. Si vous lancez une grosse consommation avec une charge bien résistive, vous aurez une courbe plus belle et en phase avec la tension.
Bonjour, j’ai réussi à corriger le plat sur la sinusoid de chaque côté avec une petite capacité de 220nf 60volts céramique en parallèle sur la résistance R5 de 4,7kohm. Il faux voir le résultat des mesures ?
Il vaut mieux éviter les capacités, car cela introduit une rotation de la phase. Lorsque l’on va comparer la phase de la tension et celle du courant pour savoir si l’on consomme ou injecte, cela va fausser les mesures. Il faut rester avec du résistif uniquement en jouant sur R4 et R5.
Cdlt
pour voir la différence j’ais essayer avec un transformateur torique rien ne change, et en varient un peux les valeurs des résistances il n’y a que très peux de changement. on doit quand même rester dans la bonne tension.
Il faut autour d’1v efficace en sortie du pont diviseur.
Regardez cet article qui donne plus de détails.
https://f1atb.fr/index.php/fr/2022/12/03/realisez-un-routeur-solaire-pour-gerer-la-surproduction/
Cdlt
Bonjour,
Tout d’abord merci pour les nombreuses vidéos très instructives sur Youtube ainsi que votre site.
Je commence à me renseigner justement pour « router » l’énergie créer par ma future installation photovoltaïque « autoconsommation » mais je ne trouve pas de réponse à ce que je désire faire sur mon installation.
J’ai déjà fait installer il y a 11 ans 3kWc de panneaux photovoltaïques sur ma toiture en « revente » totale, je vais installer dans les semaines qui arrivent 4kWc environ de panneaux (soit en pergola soit en auvent) pour de l’autoconsommation.
Je suis donc pour l’instant consommateur d’électricité venant de chez EDF, j’ai bien compris que le surplus (non consommé) de ma production de mes nouveaux panneaux est censé repartir dans le réseau gratuitement si je ne l’utilise pas, d’où l’intérêt d’avoir un routeur qui « force » la chauffe de l’eau.
L’idée pour moi, lorsque la maison (la consommation électrique habituelle) ne consomme pas assez, le chauffe eau déjà au max et les voitures électriques (il y en a une pour Mme et Mr) ne sont pas là serait que le surplus reparte dans « la ligne » de « revente » de mon installation photovoltaïque existante. Je ne compte pas envoyer la totalité de ma production (ça n’aurait aucun sens) car je suis limité de mémoire à 4500kWh pour la revente et environ 5c dépassé ce plafond.
D’après vous est-ce matériellement possible à faire ? Et si oui, partir sur un Esp32 ou Arduino avec plusieurs relais pour faire les déviations d’énergie est-il possible ?
Merci d’avance pour votre réponse.
En théorie, cela est possible d’envoyer la totalité. Contractuellement, je ne sais pas. Envoyer une partie de la puissance me semble hasardeux, sauf avec des micro-onduleurs qui permettent de commuter un panneau sur le 2eme réseau. Attention,ils auront besoin d’un temps de resynchronisation. Cela ne reste pas très flexible pour s’adapter rapidement aux variations de consommation de la maison.
Bonjour
merci beaucoup pour ces explications très instructives , cela donne envie des aire des montage avec des ESP32.
Avez vous déjà envisager d’utiliser un capteur de courant JSY – MK -194 capteur bidirectionnel à la place du capteur de courant et du transfo ?
Merci d’avance pour votre réponse
Philippe
Je n’ai jamais fait l’essai avec ce capteur. L’ensemble transfo + sonde est bien moins cher et l’ESP32 peut faire le travail de calcul.
Cdlt
Bonjour,
Est il possible de faire faire deux choses en mêmes temps à l’ESP? Par exemple, le montage de cette article et le montage de l’affichage en temps réel du Linky que vous avez présenté dans un autre article en utilisant la liaison série? J’aimerais faire les deux montages mais éviter d’utiliser deux ESP32.
Merci
De la puissance de calcul, il y en a, mais il faut réécrire du code.
Cdlt
Bonjour,
super travail, je vais donc me lancer. juste une question le routeur route à partir de quelle surplus puissance
Le routeur est prévu pour avoir en entrée de la maison une consommation ou injection nulle. Si vous produisez 200W en trop, il bascule ces 200W vers votre chauffe-eau par exemple pour revenir à une consommation/injection nulle.
Cdlt
André
Bonjour André.
Merci pour tout ce que vous partagez et expliquez !
J’ai réalisé ce routeur tout fonctionne correctement.
j’aimerai rajouter une sonde de courant. j’ai essayé plusieurs choses sur le programme pour déclarer un PIN pour cette nouvelle sonde mais je n’y arrive pas. Je n’y connais pas grand chose en C++…
Pouvez-vous juste me dire comment déclarer ce nouveau PIN ( GPI0 25 )
Je vous remercie
Cdt
Marc
const int AnalogIn3 = 25; // GPIO 25
Mais attention derrière il y a de la programmation pour lire et stocker.
Cdlt
andré
Merci.
C’est ce que j’avais fait.
C’est donc côté programmation que ça ne va pas…
cdt,
Marc