Comment mesurer une puissance de manière périodique ?

Bonjour, je voudrais savoir comment mesurer une puissance de manière périodique ( toutes les 10 secondes ) afin de pouvoir obtenir une consommation en Watts seconde (Ws) et donc de faire un mini suivi.

Pour cela j’ai : un capteur de courant pour les A avec une sensibilité de 185 mV/A

un diviseur de tension : pour obtenir la tension et bien la répartir ( “convertir” du 12v en 5v pour l’arduino)

Voici mon code :

/*****************************************

*******************
 Horloge Arduino
 
 Horloge simple avec un Arduino, un module 

breakout 
 RTC DS1307 et un afficheur LCD.
 
 Branchements du breakout RTC DS1307:
 Gnd --> GND
 Vcc --> 5 V
 Sda --> analog pin A4
 Scl --> analog pin A5
  
 Branchements de l'afficheur LCD:
 LCD RS pin --> digital pin 12
 LCD Enable pin  --> digital pin 11
 LCD D4 pin  --> digital pin 5
 LCD D5 pin  --> digital pin 4
 LCD D6 pin  --> digital pin 3
 LCD D7 pin  --> digital pin 2
 LCD R/W pin  --> ground

 
 

******************************************

*********/

#include <LiquidCrystal.h>
#include <Wire.h>
#include <RTClib.h>
#include <SPI.h>
#include <SD.h>
RTC_DS1307 RTC;
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 int Consommation = 1;
 float Voltage = 0;
 float Current = 2;
 float Power = 3;
 float Watts = 6;
 float Volts = 4;
 float Amps = 5;
 int pinpot =0;
 int pinpot1 = 0;
 unsigned long debut_mesure = 0;
 int E = 0;
 int P1=0;
 int P2 =0;
 int U1 = 0;
 int I1 = 0;
 unsigned long f = 0;
 
void setup() 
{
  Wire.begin();
  RTC.begin();
  lcd.begin(16, 2);
  P1 = U1*I1;
  P2 = E + (P1+P2/2) * 1/360;
}

void loop() 
{
    f = (millis()) - debut_mesure + 10000;
   P1= U1*I1;
  E = P1 * 1/360;
  P2 = E + (P1+P2/2) * 1/360;
  P1=P2;
  lcd.setCursor(0,2);
  lcd.print(P2);
   
  
   
   lcd.setCursor(0,1);
   lcd.print("Consommation en Wh  =  ");
   lcd.print("Wh");
   
   
  DateTime now = RTC.now();
  
  
  
  // la date sur la deuxième ligne du LCD
  
  lcd.setCursor(1, 0); 
  lcd.print(now.day()); 
  lcd.print(" "); 

  
  switch (now.month()) 
  {
  case 1:
    lcd.print("janvier");
    break;
  case 2:
    lcd.print("fevrier");
    break;
  case 3:
    lcd.print("mars");
    break;
  case 4:
    lcd.print("avril");
    break;
  case 5:
    lcd.print("mai");
    break;
  case 6:
    lcd.print("juin");
    break;
  case 7:
    lcd.print("juillet");
    break;
  case 8:
    lcd.print("aout");
    break;
  case 9:
    lcd.print("septembre");
    break;
  case 10:
    lcd.print("octobre");
    break;
  case 11:
    lcd.print("novembre");
    break;
  case 12:
    lcd.print("decembre");
    break;
  }
  lcd.print(" "); 
  lcd.print(now.year()); 
  
 
 
  
   
  
   
 
  
  delay(1000);
  lcd.clear();
}

Cependant ça ne fonctionne pas, je voudrais une mesurer de la puissance toutes les 10 secondes…

Voici le schema :

on a la simulation du capteur de courant avec les deux résistances en série d’une valeur de 10k et le potentiomètre.

Ainsi que le diviseur de tension pour obtenir la mesure du voltage.

Merci.

Bonjour,

dans ton programme on voit le calcul effectué sur les variables, mais on ne voit pas comment les valeurs de celles-ci sont acquises ?

dans ta boucle, il y a un délai d'une seconde à la fin : il est donc logique que les opérations soient réalisées toutes le secondes environ

ta variable f est déterminée dans une ligne, mais pas utilisée par la suite ?

ton affichage de puissance n'affiche pas de variable, mais "que du texte ..."

Parce qu'il vient de créer un nouveau post sur le même sujet au lieu de continuer le premier.

Voir ici : http://forum.arduino.cc/index.php?topic=463510.msg3181031#msg3181031

Pour faire perdre leur temps aux bénévoles on ne fait pas mieux.

Ce n'était pas voulu, je supprime le premier ? ou celui là ?

trimarco232: Bonjour,

dans ton programme on voit le calcul effectué sur les variables, mais on ne voit pas comment les valeurs de celles-ci sont acquises ?

d'accord, je dois les faire apparaître avec analogRead ?

trimarco232: dans ta boucle, il y a un délai d'une seconde à la fin : il est donc logique que les opérations soient réalisées toutes le secondes environ ta variable f est déterminée dans une ligne, mais pas utilisée par la suite ?

ton affichage de puissance n'affiche pas de variable, mais "que du texte ..."

Je veux que les opérations se fassent toutes les 10 secondes ... Donc il faut que j'enlève le délai du lcd d'accord.

La variable f est utilisé pour utiliser la fonction millis sinon je ne peux pas l'utiliser

Comment faire pour afficher les variables plutôt que le texte svp ? j'ai essayé avec lcd.print(P2 ) mais ca ne semble pas fonctionner ... merci

Svp?

je dois les faire apparaître avec analogRead

oui, il faut que le programme sache quelle entrée il doit traiter

Je veux que les opérations se fassent toutes les 10 secondes ... Donc il faut que j'enlève le délai du lcd d'accord

il faut que ta boucle ait un cadencement : début, lecture, calcul, affichage, délai, retour au début etc si tu veuc cadencer à 10s il faut que ton delai soit 10s (ou 10000ms...)

La variable f est utilisé pour utiliser la fonction millis sinon je ne peux pas l'utiliser

laissons cela de côté pour l'instant

j'ai essayé avec lcd.print(P2 ) mais ca ne semble pas fonctionner

tu obtiens quoi ? et qu'obtiens-tu si tu forces P2 à quelques valeurs bien choisies ?

j'obtiens une valeur fixe qui ne change pas qui est de 560 Ws ...

pour vérifier l'affichage, insère la ligne :

P2 = 67;

entre

lcd.setCursor(0,2); lcd.print(P2);

ce qui donne :

lcd.setCursor(0,2); P2 = 67; lcd.print(P2);

puis essaye avec d'autres valeurs que 67 et dis nous ce que cela affiche

Ok, merci cela fonctionne maintenant après quelques modifications même sans ta valeur 67, j'obtiens une puissance qui change toutes les 10 secondes si je modifie la tension de la batterie, et non l'intensité ce que je ne comprends pas ...

Et aussi, ce que je veux faire c'est incrémenter les anciennes puissances afin d'avoir un suivi, donc Puissance delay(10000) == > puissance 1 + 2

merci

Voici le nouveau code que j’ai modifié :

 /************************************************************
 Horloge Arduino
 
 Horloge simple avec un Arduino, un module breakout 
 RTC DS1307 et un afficheur LCD.
 
 Branchements du breakout RTC DS1307:
 Gnd --> GND
 Vcc --> 5 V
 Sda --> analog pin A4
 Scl --> analog pin A5
  
 Branchements de l'afficheur LCD:
 LCD RS pin --> digital pin 12
 LCD Enable pin  --> digital pin 11
 LCD D4 pin  --> digital pin 5
 LCD D5 pin  --> digital pin 4
 LCD D6 pin  --> digital pin 3
 LCD D7 pin  --> digital pin 2
 LCD R/W pin  --> ground

 
 ***************************************************/

#include <LiquidCrystal.h>
#include <Wire.h>                              
#include <RTClib.h>
#include <SPI.h>
#include <SD.h>
RTC_DS1307 RTC;

 // Inclusion des différentes bibliothèques
 
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);    // L'afficheur LCD est branché aux bornes (12 , 11 , 5 , 4 , 3 ,2)
 
 long Power =0;
 long Power1 = 0;
 unsigned long debut_mesure = 0;
 int E = 0;
 int P1=0;
 int P2 =0;
 int U1 = 0;
 int I1 = 0;
 unsigned long f = 0;
 
void setup() 
{
   Wire.begin();                // Initialisation de la bibliothèque Wire et se connecte au bus I2C
   RTC.begin();                 // Initialisation de la bibliothèque  horloge et se connecte au bus I2C
   lcd.begin(20, 4);            // positionne le curseur de l'afficheur LCD avec 20 colonnes et 4 lignes (20*4)
  
}

void loop() 
{    
    
    
   f = (millis()) - debut_mesure + 10000;   
   P1= U1*I1;                          // Puissance 1 = Tension de mesure 1 * Intensité de mesure 1
   E = P1 * 1/360;                    // Energie = Puissance 1 * 1/360 pour obtenir des Ws
   P2 = E + (P1+P2/2) * 1/360;        // P2 = Energie + (variable P1 et P2 divisée par 2 puis multipliée par 1/360 pour obtenir des Watt par secondes.
   P1=P2;                             // Variable P1 = variable P2
   
   P1 = analogRead(Power1);           // lecture de la variable P1
   P2= analogRead(Power);             // lecture de la variable P2
 
     
   
  
   
   lcd.setCursor(0,1);                   // Défini le curseur de l'afficheur LCD à la position (0,1)
   lcd.print("Consommation en Ws  =  ");  // Affiche sur l'afficheur LCD le texte : Consommation en Ws
   lcd.print(P2);                          // Affiche la variable P2 sur le LCD
   lcd.print("Ws");                        // Affiche les unités "Ws" sur le LCD 

   
   DateTime now = RTC.now();        // Heure actuel 
  
  
  
    // la date sur la deuxième ligne du LCD
  
   lcd.setCursor(1, 0);           // Défini la position des jours sur l'afficheur LCD en position (0,1)
   lcd.print(now.day());          // Affiche les jours de l'année sur l'afficheur LCD 
   lcd.print(" ");                // Affiche un espace

  
   switch (now.month()) 
   {
   case 1:
     lcd.print("janvier");       // Affichage du mois de janvier 
     break;
   case 2:
     lcd.print("fevrier");        // Affichage du mois de février 
    break;
   case 3:
     lcd.print("mars");           // Affichage du mois de mars
     break;
   case 4:
     lcd.print("avril");          // Affichage du mois d'avril
     break;
   case 5:
     lcd.print("mai");           // Affichage du mois de mai 
     break;
   case 6:
     lcd.print("juin");         // Affichage du mois de juin 
     break;
   case 7:
     lcd.print("juillet");     // Affichage du mois de juillet
     break;
   case 8:
     lcd.print("aout");        // Affichage du mois d'aout
     break;
   case 9:
     lcd.print("septembre");     // Affichage du mois de septembre
     break;
   case 10:
     lcd.print("octobre");      // Affichage du mois d'octobre
     break;
   case 11:
     lcd.print("novembre");     // Affichage du mois de novembre
     break;
   case 12:
     lcd.print("decembre");      // Affichage du mois de decembre 
     break;
   }
   lcd.print(" ");           // Affichage de l'espace
   lcd.print(now.year());    // affiche le mois de l'année selon le mois actuel
  
 
 
  
   
  delay(10000);    // délai de 10s afin d'avoir un raffraichissement de 10s sur l'afficheur LCD 
   
 
  

  lcd.clear();    // Efface  les précédentes valeurs  de l'écran LCD 
}

Ce code m’affiche la puissance mais uniquement selon la variation de tension et non d’intensité ce qui est pas normal …
De plus il ne m’affiche pas les anciennes mesures, c’est à dire que si je fais varier la tension, j’obtiens une nouvelle mesure alors que moi je voudrais ajouter les précédentes mesures à la nouvelle pour que la nouvelle mesure est égale au total des anciennes …

Je suis vraiment perdu, merci aux personnes qui m’ont aidés et qui m’aideront ( si on m’aide x) )

Bonjour, normalement le courant se mesure aux bornes d'un shunt qui est en principe une résistance de faible valeur : je ne vois rien transpirer de tel de ton schéma ?

Oui, effectivement cependant dans ce cas là, j’ai utilisé un calcul avec la sensibilité du capteur de courant 0,185mv/a pour calculer la valeur de la résistance du potentiomètre
est-ce faux ?

c'est vrai tu en avais parlé, mais je n'ai pas vu ce capteur dans le schéma : peux-tu faire un schéma de ton montage (papier crayon c'est ok) pour que nous parlions de la même chose ?

Salut vraiment désolé pour le retard, voici le schema du constructeur : http://www.microbot.it/documents/ACS714-Datasheet.pdf

Quant au capteur : il a une tension de 2,5 v pour 0 A en plus des 0,185v/A

Ce qui fait : 5V * 0,185 = 0,925 , 0,925 + 2,5 v = 3,42 V

Mon nouveau programme mais qui ne fonctionne pas du tout, j'ai compris niveau théoriquement mais pratiquement je ne comprends pas, il ne fonctionne pas les calculs reste les mêmes ...

 unsigned long debut_mesure = millis();      // initialisation de toutes les variables
 float energieCons = 0;
 float p1=0;
 float p2 =0;
 float uBatt = 0;
 float iBatt = 0;


void setup() 
{
   analogReference(EXTERNAL);
   Wire.begin();                         // Initialisation de la bibliothèque Wire et se connecte au bus I2C
   // RTC.begin();                          // Initialisation de la bibliothèque  horloge et se connecte au bus I2C
  // lcd.begin(16, 4);                          // positionne le curseur de l'afficheur LCD avec 26 colonnes et 4 lignes (16*4)
   Serial.begin(9600);                    // Initialise le baudrate
   uBatt=analogRead(A0);                     // on lit la valeur sur AD0
   uBatt = (A0 * 3.3) / 1024;                    //On fait le calcul à partir de la valeur lue sur Ad0
   iBatt=analogRead(A1);                               // on lit la valeur sur AD1
   iBatt = (A1 * 3.3)  / ( 1024 * 0.185) - (2.5/0.185);     // on fait le calcul à partir de la valeur sur AD1

   p1 = uBatt * iBatt;         // Puissance1 est égale au produit de l'intensité de la batterie et de sa tension
}

void loop() 
{    
    if (millis() > debut_mesure + 1000)    // temps réglé à 1seconde pour la simulation
    {
    
  
    
    uBatt = analogRead(A0);                   
    uBatt = (A0 * 3.3) / 1024;
  
   iBatt = analogRead(A1);                                              // les calculs sont faits
   iBatt = (A1 * 3.3) / (1024*0.185) - (2.5/0.185);

   p2 = uBatt * iBatt;
   energieCons = energieCons + ((p1+p2) /2) * (1/3600000);        // Avoir l'énergie en Wh 
   p1=p2;       // Incrémenter les puissances
   
  
   
   delay(1000);
   
 // lcd.setCursor(1,2);
   Serial.print(iBatt);
   Serial.println("A");         // Affichage des variables sur le moniteur série
   
delay (1000);
 //  lcd.setCursor(0,4);
   Serial.print(uBatt);  
   Serial.println("V");
   
  
  //lcd.setCursor(3,4);
  Serial.print(p1);
  Serial.println("wH");
   
   
  }
}

je me concentre donc que sur l'essentiel, j'ai mis la tension en external pour avoir la tension en 3.3V et donc améliorer la précision de mes capteurs...

J'ai vraiment un problème pour la lecture des valeurs ...

Souvent c'est mieux de commencer par le commencement. Trimarco232 t'as dit :

trimarco232: peux-tu faire un schéma de ton montage (papier crayon c'est ok) pour que nous parlions de la même chose ?

j'ai envoyé le data sheet du capteur, et ouais je vais faire le schema de mon montage

Bonjour, Tant que tu y es vérifie avec un simple multimètre que ce que tu mesure en sortie du montage comprenant le capteur est correct. L'entrée ADC du micro n'est rien d'autre qu'un multimètre. Tu mets en route un ustensile dont la consommation est connue et tu vérifie avec le multimètre que le résultat n'est pas déconnant. Comme cela tu éliminera les possibles erreurs de programation et tu validera ton utilisation du capteur.

non la valeur est fausse :(

non la valeur est fausse

Ce n'est pas une réponse.

Qu'est ce que tu mesure ? On ne joue pas au devinettes, on fait de la technique.

Une réponse doit être : 1) j'ai placer un "objet" qui consomme X watt, 2) Compte tenu que la tension est 230V (le 220V c'est fini depuis 20 ans !) je devrai trouver X/230 ampères 3) Je ne mesure en sortie du capteur que X volts.

Tu n'as toujours pas fourni le schéma de câblage. Je peux me tromper mais vu la façon dont tu a présenté la fonction de transfert du capteur :

Quant au capteur : il a une tension de 2,5 v pour 0 A en plus des 0,185v/A

je subodore une mauvaise utilisation. Un schéma de câblage lèvera le doute. De toute façon en tant qu'électronicien je n'ai jamais pu travailler sans schéma de câblage, tous mes anciens collègues également. Croire qu'on a le schéma dans la tête est une absurdité.