Probleme avec capteur de courant ACS712

Bonjour,
je veux utiliser un capteur de courant du type ACS712 (30A)dans un montage me permettant de contrôler si une pompe immergée de puit est en fonction ou pas. Ceci afin de détecter les déclenchements intempestifs dus à un fuite sur le réseau.
Le montage est très simple et j’utilise le sketch ce trouvant sur le site marchand sur lequel j’ai acheté le module ACS712.
Afin de tester le montage j’utilise un projecteur Halogene.

Le résultat sur le moniteur me laisse perplexe.
Pourquoi des valeurs négatives apparaissent elles alors que le projecteur est en fonction.
Pourquoi les valeur mesurées sont elles inférieures à la valeur de départ initialisant le calcul.
Mon sketch de contrôle futur partait du principe d’envoyer une information quand il y a consommation donc valeur > à zero.

Existe t’il un moyen de rendre plus precise la mesure?
Le sketch est il mauvais?
Dois je simplement partir sur un autre type de contrôleur?
Dois je modifier ma méthode de contrôle s’il y à conssomation ou pas.
Je suis ouvert à toutes vos idées.
Merci

zero_senseur lecture courant efficace (mA) Puissance (W)
511.94 511.94 0.00mA 0.00W Projecteur Eteint
511.94 469.44 -146.76m A **-33.75 W ** Projecteur Eteint
511.94 543.40 108.64mA 24.99 W Projecteur allumé
511.94 535.56 81.56mA 18.76 W Projecteur allumé
511.94 482.76 -100.76mA -23.18 W Projecteur allumé

float zero_senseur; 
int PIN_ACS712 = A1;

// Obtient la valeur du senseur de courant ACS712
//
// Effectue plusieurs lecture et calcule la moyenne pour pondérer
// la valeur obtenue.
float valeurACS712( int pin ){
  int valeur;
  float moyenne = 0;
  
  int nbr_lectures = 50;
  for( int i = 0; i < nbr_lectures; i++ ){
      valeur = analogRead( pin );
      moyenne = moyenne + float(valeur);
  }
  moyenne = moyenne / float(nbr_lectures);
  return moyenne;
}

void setup(){
  // calibration du senseur  (SANS COURANT)
  zero_senseur = valeurACS712( PIN_ACS712 );
  
  Serial.begin( 9600 );
}

float courant; 
float courant_efficace;     
float tension_efficace = 230; // tension efficace du réseau electrique
float puissance_efficace; 
float ACS712_RAPPORT = 66; // nbr de millivolts par ampère pour capeteur 30A

void loop(){
  float valeur_senseur = valeurACS712( PIN_ACS712 );
  // L'amplitude en courant est ici retournée en mA
  // plus confortable pour les calculs
  courant = (float)(valeur_senseur-zero_senseur)/1024*5/ACS712_RAPPORT*100000;
  // Courant efficace en mA
  courant_efficace = courant / 1.414; // divisé par racine de 2

  // Calcul de la puissance.
  //    On divise par 1000 pour transformer les mA en Ampère
  puissance_efficace = (courant_efficace * tension_efficace/1000);
  
  Serial.println( "zero_senseur - lecture - courant efficace (mA) - Puissance (W)" );
  Serial.print( zero_senseur );
  Serial.print( " - " );
  Serial.print( valeur_senseur );
  Serial.print( " - " );
  Serial.print( courant_efficace );
  Serial.print( "mA - " );
  Serial.print( puissance_efficace );
  Serial.println( " W" );
  
  delay( 1000 ); // attendre une seconde 
}

Bonjour,

Tu es sûr de ton montage ?

L'ACS712 est fait pour mesurer un courant continu alors que tu mesures un courant alternatif. Ca ne peut pas fonctionner (ou disons plutôt qu'avoir ces valeurs dans ces conditions est normal).

Bonjour a tous,
une petite recherche sur Google avec : "ACS712 Arduino AC current"
et le premier lien trouve donne ceci :
How to Measure AC Current with an Arduino and an ASC712 (c'est ici)

Bonne journee

Jacques

Bonjour

L'ACS712 permet sans problème de répondre à ce besoin, il faut juste s'assurer que sa plage de fonctionnement (en Ampères) est compatible avec la pompe, car il existe plusieurs modèles d'ACS712.

Par contre il faut prendre en compte le fait que la tension (donc le courant) est alternative à 50 Hz.

L'ACS712 permet d'avoir une vision du courant à un instant t.
Ce courant a grosso-modo une forme de sinusoide avec une période de 1/50 de seconde.

Une méthode de détection de la pompe en marche consiste à déclencher les lectures en rafale pendant 1/50 de seconde, garder les valeurs min et max lues, calculer l'amplitude max - min, et de comparer cette amplitude à un seuil paramétré en fonction de la puissance de la pompe (faire des tests à vide et en charge pour déterminer la bonne valeur de seuil).

Perso je partirais sur cette base très simple

int PIN_ACS712 = A1;

int amplitude(int pin){
  const unsigned long duree_mesure = 20; // en ms
  int valmin = 1023;
  int valmax = 0;
  unsigned long chrono = millis();
  while (millis() - chrono < duree_mesure) {
    int val = analogRead( pin );
    if (val < valmin) valmin = val;
    if (val > valmax) valmax = val;
  }
  return valmax - valmin;
}

void setup(){
  Serial.begin(9600);
}

void loop(){
  Serial.print("Amplitude=");
  Serial.println(amplitude(PIN_ACS712));
  delay(1000);
}

Merci à vous tous.
Je travaille dessus et vous informe.

Bonsoir,
Alors, après avoir essayé le sketch de Bricoleau, cela fonctionne et répond à mes attentes.
Question,car j'aime bien comprendre, et je m'adresse à Bricoleau, pourquoi utiliser pour la variable "valmin", 1023.
Cela correspond à quoi?
Merci pour votre attention.

1023 est la valeur la plus grande que peut retourner un analogRead

Cette initialisation "à l'envers" des variables min et max permet juste de s'assurer que la première valeur lue viendra mettre à jour les deux bornes

Merci à toi Bricoleau pour l'attention portée.

Salut tout le monde

j’essaye de mesurer l’ampérage d’un moteur avec mon arduino nano mais je reçois le même problème puisqu’il n’y a que des valeurs négatives qui s’affichent. j’ai testé le schéma ci joint puis j’ai utilisé ce même code pour afficher uniquement l’ampérage

float zero_senseur;
int PIN_ACS712 = A1;

float valeurACS712( int pin )
{
int valeur;
float moyenne = 0;
int nbr_lectures = 50;

for( int i = 0; i < nbr_lectures; i++ )
{
valeur = analogRead( pin );
moyenne = moyenne + float(valeur);
}
moyenne = moyenne / float(nbr_lectures);
return moyenne;
}

void setup()
{
// calibration du senseur (SANS COURANT)
zero_senseur = valeurACS712( PIN_ACS712 );
Serial.begin( 9600 );
}

float courant;
float courant_efficace;
float ACS712_RAPPORT = 66;

void loop(){
float valeur_senseur = valeurACS712( PIN_ACS712 );
courant = (float)(valeur_senseur-zero_senseur)/10245/ACS712_RAPPORT100000;
courant_efficace = courant / 1.414;
Serial.print( courant_efficace );
Serial.println( “mA” );
delay( 1000 );
}

Normalement avec mon amperemetre ça affiche 12.92ma mais au lieu de ça je reçois que des valeurs négatives et même pas proche à la vrai valeur

Que quelqu’un m’aide s’il vous plait

Pour les valeurs négative essaye d'inverser le sens du courant.
Ce circuit intégré est prévu pour mesurer aussi des tensions alternatives, si en continu tu n'entres pas sur la bonne entrée c'est normal qu'il t'indique du négatif.

Ceci réglé regarde si le problème de la valeur persiste.

Attention ce circuit intégré est prévu pour mesurer des forts courants : le modèle le plus sensible est un modèle 5A, il existe des modèles 20 et 30 A.
Il n'est pas adapté à la mesure de courant de l'ordre de 10 mA --> le niveau de bruit électrique est du même ordre de grandeur que le courant à mesurer.

Salut

Pour mesurer des courants faibles continus, oriente-toi plutôt sur un INA138, ou mieux un INA219 ou INA226 fonctionnant en I2C.
Ces modules sont souvent équipés de shunts 10mΩ ou 100mΩ qu'il suffit de changer pour mesurer des courants plus faibles.

@+

bonjour a tous