Problème de ACS712-20A

bonjour, je veux mesurer le courant délivrer par un panneau solaire de Imax= 3A, j'ai utilisé un capteur ACS712-20A , mais sur le moniteur série le courant est 0A alors que le multimètre affiche des valeurs qui varient entre 0 et 2.8A. je vais envoyer le code Arduino pour que vous puissiez m'aider à trouver la cause du problème merci.

const int pinAC712 = A1;
const float sensibivity = 0.100;
float Current=0;

void setup() {
    Serial.begin(9600);
    pinMode(pinAC712, INPUT);
}

void loop() {
   delay(1000);
   
        // Mesurer le courant Serial.print(Current);
      uint8_t sensorValue = analogRead(pinAC712);
      float Value = sensorValue * 5 / 1023.0;
      Current = (Value - 2.5) / sensibivity;
        
        
        // Écrire les données sur le moniteur série
        
        Serial.print(Current);
        Serial.println("  ");
            
}

La langue de la section anglaise du forum est l'anglais, la langue de la section française du forum est le français.

Votre sujet a donc été déplacé

analogRead(pinAC712) renvoi un valeur sur 10bits

1 Like

Bonjour et bienvenue,

Merci de prendre quelques minutes pour lire "Les bonnes pratiques du forum francophone" et les appliquer.


à remplacer par

      uint16_t sensorValue = analogRead(pinAC712);
      float Value = sensorValue * 5.0 / 1023.0;
1 Like

merci , seulement lorsque je compile et le capteur est à vide voilà les valeurs que j'obtiens

0.07  
-0.17  
-0.17  
-0.02  
-0.07  
-0.22  
-0.07  
-0.12  
-0.07  
-0.17  
-0.07  
-0.07  
-0.07  
-0.07  
0.02  
-0.17  

ce capteur se branche en série avec la charge sur le circuit alternatif ➜ est-ce branché comme cela ? (un petit schéma serait bien)

Le module propose en sortie une tension continue proportionnelle au courant à raison de 100mV par ampère ➜ Vous pouvez donc lire cette tension sur une entrée analogique de votre Arduino et obtenir une valeur de courant (A) . vous faites sensorValue * 5 / 1023 ➜ il faudrait tenir compte du 0.1V/A

Il est important de faire une lecture a vide (sans courant) pour obtenir la valeur de calibration Vref du module (qui devrait être Vcc/2 soit 2.5V).

un analogRead() n'a pas besoin de déclarer la pin en INPUT. On ne s'en sert que lorsque l'ont veut travailler en tout ou rien (digitalRead).

le uint16_t n'est pas une bonne idée dans l'absolu car bien que analogRead ne retourne que des valeurs positives, la fonction est définie comme retournant un int donc ceci serait mieux

      int sensorValue = analogRead(pinAC712);
      float Value = sensorValue * 5.0 / 1023.0;

et on peut faire juste d'ailleurs :

      float Value = analogRead(pinAC712) * 5.0 / 1023.0;
1 Like

merci monsieur , j'ai appliqué vos remarques et voilà ce que le capteur donne à vide , Vref et le courant à vide

2:41:43.930 -> 2.49  -0.17  
12:41:44.962 -> 2.48  -0.22  
12:41:45.949 -> 2.48  -0.07  
12:41:46.941 -> 2.49  -0.17  
12:41:47.973 -> 2.48  -0.12  
12:41:48.966 -> 2.49  -0.12  
12:41:49.956 -> 2.49  -0.12  
12:41:50.940 -> 2.49  -0.12  
12:41:51.955 -> 2.49  -0.12  
12:41:52.938 -> 2.49  0.02  
12:41:53.939 -> 2.50  -0.07  
12:41:54.971 -> 2.49  -0.12  
12:41:55.953 -> 2.49  -0.17  
12:41:56.939 -> 2.48  -0.17  

et lorsque j'ai essayer de connecté une charge au capteur, il donne des valeurs erronées différents ce que le multimètre affiche .

Maintenant, il faut faire ça dans le setup en faisant la moyenne sur une vingtaine d'acquisition.
Conserver le "Vref" et l'utiliser dans cette expression à la place de 2.5

OK on est quasiment à 50% des 5V, c'est pas mal

Pour éviter de perdre trop en précision, il faut essayer de conserver les entiers le plus longtemps possible

pouvez vous faire tourner ce code sans courant pour voir la vref en nombre entier (ça doit être proche de 512)

const byte pinAC712 = A1;

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

void loop() {
 int sensorValue = analogRead(pinAC712);
 Serial.print(F("Valeur brute : ")); 
 Serial.println(sensorValue);
 delay(1000);
}

pouvez vous poster une photo de votre montage ?

merci monsieur, lorsque j'ai fais tourner le code voilà ce que j'obtiens

Valeur brute : 509
Valeur brute : 506
Valeur brute : 509
Valeur brute : 505
Valeur brute : 508
Valeur brute : 508
Valeur brute : 509
Valeur brute : 508
Valeur brute : 508
Valeur brute : 505
Valeur brute : 508
Valeur brute : 506
Valeur brute : 507
Valeur brute : 507
Valeur brute : 506
Valeur brute : 508
Valeur brute : 510
Valeur brute : 507
Valeur brute : 506
Valeur brute : 506
Valeur brute : 507
Valeur brute : 507
Valeur brute : 508
Valeur brute : 507
Valeur brute : 507
Valeur brute : 506
Valeur brute : 507
Valeur brute : 504
Valeur brute : 507
Valeur brute : 508
Valeur brute : 507
Valeur brute : 505
Valeur brute : 508
Valeur brute : 506
Valeur brute : 507
Valeur brute : 507
Valeur brute : 504
Valeur brute : 505

(pas la peine de m'appeler Monsieur :slight_smile: )

et pour cela ?

(quand vous branchez le courant)


pour la valeur brute, si on fait la moyenne de vos lectures, on a quasiment 507. (506,92)

au lieu de faire tout de suite des calculs en nombre à virgule

      uint8_t sensorValue = analogRead(pinAC712);
      float Value = sensorValue * 5 / 1023.0;
      Current = (Value - 2.5) / sensibivity;

faites

      int sensorValue = analogRead(pinAC712); // la valeur brute
      int valeurCalibree =  sensorValue - 507; 
      float tensionCalibree_mV =  (valeurCalibree * 5000) / 1023.0; 
      float courant = tensionCalibree_mV / 100; //  100mV / A

ce qui revient à écrire

      int sensorValue = analogRead(pinAC712); // la valeur brute
      int valeurCalibree =  sensorValue - 507; 
      float courant =  (valeurCalibree * 50) / 1023.0; 

essayez ce code

const byte pinAC712 = A1;
const int vRefBrute = 507;
const int vccBrute = 1023;
const int facteur = 50;
float oldCourant = -1;

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

void loop() {
  int valeurBrute = analogRead(pinAC712); // la valeur brute
  int valeurCalibree =  valeurBrute - vRefBrute;
  float courant =  ((float) (valeurCalibree * facteur)) / vccBrute;
  if (courant != oldCourant) {
    Serial.print(courant); Serial.println(" A");
    oldCourant = courant;
  }
}

d'accord j'ai compilé le code et voilà ce que sa donne

-0.39 A
-0.44 A
-0.49 A
-0.29 A
-0.39 A
-0.54 A
-0.34 A
-0.49 A
-0.44 A
-0.49 A
-0.44 A
-0.49 A
-0.59 A
-0.44 A
-0.39 A
-0.44 A
-0.54 A
-0.39 A
-0.49 A
-0.39 A
-0.44 A
-0.49 A
-0.54 A
-0.39 A
-0.49 A
-0.54 A
-0.39 A
-0.54 A
-0.39 A
-0.49 A
-0.34 A
-0.44 A
-0.49 A
-0.59 A
-0.29 A
-0.54 A

avec ou sans courant ?

sans courant

oui c'est quasiment 0A donc - la variation provient du fait que votre lecture sans courant n'est pas stable (la valeur brute varie de 505 à 509 donc en prenant 507 forcément on est parfois au dessus, parfois en dessous)

Ce serait bien de réduire la longueur des fils entre le module ACS712 et l'Arduino pour réduire le bruit autant que possible.

Les cartes Arduino ne sont pas réputées pour la qualité de leur acquisition analogique. Je pense qu'une moyenne sur quelques échantillons donnerait de meilleurs résultats.

A noter, la datasheet indique aussi 11mV de bruit crête-crête sur la mesure. Ce qui rapporté à l'ADC de l'ATmega fait 2 LSB à quoi il faut ajouter le bruit propre à l'ADC tel qu'il est implanté sur la carte. Donc le bruit constaté n'est pas très choquant en soit.

Un bon filtrage devrait améliorer les choses. D'autant que le courant délivré par les panneaux solaires ne varie pas très rapidement en principe.

oui sans doute

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.