Capteur de courant ACS712 Arduino : mesurer le courant DC et AC

Le capteur de courant ACS712 est un petit module bon marché qui détecte le courant traversant un circuit grâce à l'effet Hall et le convertit en une tension que ton Arduino peut lire. Sans courant, sa sortie est à environ 2,5 V ; elle monte quand le courant circule dans un sens et descend quand il circule dans l'autre. Tu peux ainsi mesurer le courant continu (DC) comme le courant alternatif (AC) avec une seule broche analogique. On l'utilise pour voir combien de courant consomme un moteur, suivre la décharge d'une batterie, savoir si un appareil fonctionne ou calculer la puissance d'un appareil électroménager. En plus, la ligne mesurée est isolée électriquement du côté Arduino.

Dans ce guide, tu vas apprendre pas à pas ce que contient l'ACS712, ce qui distingue les modèles 5A, 20A et 30A et lequel choisir, comment brancher le module en série dans ton circuit, le premier programme Arduino qui mesure un courant continu, comment calmer les valeurs instables par la moyenne, comment calculer la valeur efficace (RMS) d'un courant alternatif et comment obtenir la puissance (W) et l'énergie (Wh). Ensuite, tu verras comment le relier à l'ESP32 et au Raspberry Pi Pico en 3,3 V avec un pont diviseur, pourquoi il faut être très prudent avec le secteur 230 V et pourquoi l'INA219 est un meilleur choix pour les petits courants.

Qu'est-ce que le capteur de courant ACS712 et comment fonctionne-t-il ?

L'ACS712 est une puce à 8 broches fabriquée par Allegro. Le courant mesuré traverse un épais chemin de cuivre à l'intérieur de la puce, des broches 1 et 2 vers les broches 3 et 4. Ce chemin n'a qu'une résistance de 1,2 mΩ ; même à 10 A, la chute n'est que de 12 mV pour 0,12 W de chaleur, il ne perturbe donc presque pas le circuit mesuré. En traversant ce conducteur, le courant crée un champ magnétique proportionnel. Un capteur à effet Hall placé juste au-dessus du cuivre détecte ce champ, et un amplificateur interne le transforme en tension. Tu trouveras les bases en détail dans notre guide sur les capteurs à effet Hall.

Il n'y a aucune liaison électrique entre le chemin de cuivre parcouru par le courant et le côté qui alimente la puce ; le seul lien est le champ magnétique. C'est pourquoi la ligne mesurée et l'Arduino sont isolés l'un de l'autre (isolation galvanique). La tension de sortie suit cette formule : Vout = VCC / 2 + Sensibilité × I. Si le courant va de IP+ vers IP−, la sortie passe au-dessus de 2,5 V ; dans l'autre sens, elle passe en dessous. L'ACS712 est aussi ratiométrique : le point zéro et la sensibilité varient avec la tension d'alimentation. Si celle-ci tombe à 4,8 V, le point zéro devient 2,4 V et la sensibilité du modèle 5A passe de 185 à environ 178 mV/A.

Modèles 5A, 20A et 30A : sensibilité et résolution

L'ACS712 existe en trois versions qui se ressemblent comme deux gouttes d'eau. Pour savoir laquelle tu as, lis le marquage de la puce : ELC-05B mesure ±5 A, ELC-20A ±20 A et ELC-30A ±30 A. La sensibilité indique de combien de millivolts la sortie varie pour chaque ampère. Plus la plage est grande, plus la sensibilité est faible, afin que la sortie des modèles 20A et 30A reste entre 0,5 et 4,5 V même au courant maximal. Le tableau montre aussi à combien de milliampères correspond un pas du CAN 10 bits de l'Uno (4,88 mV) pour chaque modèle.

Deux conclusions importantes ressortent du tableau. D'abord, le bruit exprimé en ampères vaut environ 0,1 A sur les trois modèles ; si tu prends le 30A pour une charge de 2 A, tu gâches les deux tiers de la résolution. La règle est simple : choisis le plus petit modèle qui couvre avec marge le courant maximal à mesurer (la valeur crête en alternatif). Par exemple, le 5A convient à un moteur 12 V qui consomme au plus 2–3 A, et le 20A à un radiateur de 1500 W. Ensuite, l'ACS712 n'est pas fait pour les petits courants : tu ne pourras pas mesurer avec lui une LED de quelques milliampères ni un ESP32 en sommeil profond. Pour cela, l'INA219 présenté à la fin de ce guide est bien meilleur.

Branchement de l'ACS712 : Arduino Uno, ESP32 et Pico

Le module ACS712 a deux côtés. Le côté bornier appartient au circuit mesuré : le courant doit entrer par une borne et ressortir par l'autre, le module se branche donc en série avec la charge, exactement comme un ampèremètre. En général, tu coupes le fil positif de l'alimentation, tu relies l'extrémité venant de l'alimentation à une borne et celle qui part vers la charge à l'autre. Le côté à trois broches va vers l'Arduino. L'ACS712 ne fonctionne qu'en 5 V ; sur l'ESP32 et le Pico aussi, tu l'alimentes depuis une broche 5 V et tu lis sa sortie à travers un pont diviseur.

À part la puce, le module porte très peu de composants : un condensateur de découplage sur l'alimentation, un petit condensateur sur la broche FILTER qui fixe la bande passante, la LED témoin (D1) et sa résistance (R1). Le 102 imprimé sur R1 signifie 1 kΩ ; tu peux décoder ces marquages facilement avec le décodeur de codes CMS. Comme l'ACS712 est isolé, il n'est pas nécessaire de relier le moins du circuit mesuré au GND de l'Arduino quand tu mesures seulement le courant.

Pas à pas : mesurer un courant continu avec Arduino

1. Relie VCC du module à la broche 5V de l'Arduino, GND à GND et OUT à A0. La LED témoin de la carte doit s'allumer.
2. Coupe le fil positif du circuit à mesurer : l'extrémité venant de l'alimentation va sur une borne, celle qui part vers la charge (par exemple un moteur 12 V ou un ruban LED) sur l'autre.
3. Laisse l'alimentation de la charge éteinte et téléverse le programme ci-dessous. Au démarrage, il mesure le point zéro pendant qu'aucun courant ne circule.
4. Ouvre le moniteur série à 9600 bauds ; sans courant, la valeur doit rester autour de 0,00 A et varier au plus de quelques centièmes d'ampère.
5. Allume l'alimentation de la charge. Si le courant est négatif, inverse les deux fils du bornier ou multiplie le résultat par −1.
6. Règle SENSITIVITY dans le code selon ton modèle : 0.185 pour le 5A, 0.100 pour le 20A et 0.066 pour le 30A.

1// ACS712 ile DC akım ölçme / DC current measurement with ACS712
2const int SENSOR_PIN = A0;            // ACS712 OUT pini / ACS712 OUT pin
3const float SENSITIVITY = 0.185;      // V/A: 5A=0.185, 20A=0.100, 30A=0.066
4const float ADC_STEP = 5.0 / 1024.0;  // bir ADC basamağı (V) / one ADC step (V)
5const int SAMPLES = 200;              // ortalama için örnek sayısı / samples to average
6
7float zeroRaw = 512.0;                // akım yokken ham değer / raw value at zero current
8
9// SAMPLES kez okuyup ortalamayı döndürür / reads SAMPLES times and returns the average
10float readAverageRaw() {
11  long sum = 0;
12  for (int i = 0; i < SAMPLES; i++) {
13    sum += analogRead(SENSOR_PIN);
14  }
15  return sum / (float)SAMPLES;
16}
17
18void setup() {
19  Serial.begin(9600);
20  delay(500);                         // sensörün oturmasını bekle / let the sensor settle
21  zeroRaw = readAverageRaw();         // yük KAPALIYKEN sıfır noktası / zero point with the load OFF
22  Serial.print(F("Sifir noktasi / Zero point: "));
23  Serial.print(zeroRaw * ADC_STEP, 3);
24  Serial.println(F(" V"));
25}
26
27void loop() {
28  float raw = readAverageRaw();
29  float current = (raw - zeroRaw) * ADC_STEP / SENSITIVITY;  // amper / amps
30
31  Serial.print(F("Akim / Current: "));
32  Serial.print(current, 2);
33  Serial.println(F(" A"));
34  delay(500);
35}

À chaque mesure, le programme fait la moyenne de 200 lectures analogRead ; comme une lecture prend environ 0,11 ms sur l'Uno, cela représente à peu près 22 ms. Le courant se calcule avec I = (brut − zéro) × (5 / 1024) / sensibilité. Par exemple, sur le modèle 5A avec un point zéro de 512, une moyenne de 550 donne un écart de 38 pas ; cela fait 38 × 4,88 mV = 185,5 mV, donc un courant de 185,5 / 185 ≈ 1,00 A. Mesurer le point zéro au démarrage au lieu de supposer 2,5 V est important, car le décalage propre de la puce et de petites différences sur la masse de la carte le déplacent de quelques pas, et cette erreur s'ajoute à chaque mesure.

Bruit et moyenne

La sortie de l'ACS712 tremble sans arrêt, même à courant constant. La première cause est le bruit propre du capteur Hall : le fabricant donne les valeurs de bruit ci-dessus avec un condensateur de 47 nF sur la broche FILTER, soit une bande passante d'environ 2 kHz. Or la plupart des modules n'y ont que 1 nF, comme le schéma d'exemple du fabricant ; la bande passante monte à 80 kHz et le bruit est plusieurs fois plus élevé. La seconde cause est le CAN : même avec le modèle 5A, l'Uno mesure par pas de 26 mA, et le dernier pas oscille toujours. Le bruit aléatoire diminue avec la racine carrée du nombre d'échantillons moyennés : 16 échantillons le divisent par quatre, 256 par seize. Pour d'autres méthodes, consulte notre guide pour filtrer les données d'un capteur.

• Moyenne sur de nombreux échantillons : en continu, fais la moyenne de 100 à 500 échantillons. Si tu les répartis sur 20 ms, le parasite à 50 Hz venant du secteur s'annule aussi dans la moyenne.
• Moyenne mobile exponentielle : mélange chaque nouvelle mesure à l'ancienne avec filtre = filtre + 0,1 × (nouveau − filtre) ; elle ne consomme presque pas de mémoire et donne un affichage stable.
• Zone morte : si tu ne veux pas voir de valeurs comme 0,03 A sans rien de branché, considère comme 0 les résultats dont la valeur absolue est inférieure à 0,05 A.
• Filtre matériel : si tu sais souder, ajoute 47 nF en parallèle avec le condensateur de la broche FILTER pour ramener la bande passante à environ 2 kHz ; c'est largement suffisant en continu et pour le courant secteur à 50 Hz.
• Éloigne-le des champs magnétiques : l'ACS712 est un capteur Hall ; un aimant, un haut-parleur ou un autre câble parcouru par un fort courant à proximité décale la mesure.
• Remesure le point zéro : il dérive de quelques millivolts avec la température ; dans les projets qui tournent longtemps, mesure à nouveau le zéro charge éteinte.

La moyenne supprime le bruit mais ne corrige pas l'erreur systématique. La sensibilité peut varier de quelques pour cent d'une puce à l'autre ; sur le modèle 5A, elle se situe entre 180 et 190 mV/A. Pour la meilleure précision, branche un multimètre sur le calibre courant en série dans la même ligne que l'ACS712, fais passer un courant connu de 1 à 2 A et compare les deux valeurs. Si le multimètre affiche 2,00 A et l'Arduino 1,94 A, ton facteur de correction est 2,00 / 1,94 = 1,031 ; divise SENSITIVITY dans le code par ce nombre (0,185 / 1,031 ≈ 0,179) et ta mesure collera à celle du multimètre.

Mesurer un courant alternatif : le calcul RMS

Le courant du secteur change sans cesse de sens : 50 Hz en France, en Belgique, en Suisse et dans la plupart des pays, 60 Hz au Canada et aux États-Unis. La sortie de l'ACS712 dessine donc une sinusoïde autour de 2,5 V dont la moyenne correspond à un courant nul ; si tu lances le programme DC sur une charge alternative, tu obtiens des valeurs absurdes proches de 0 A. En alternatif, la grandeur utile est la valeur efficace (RMS) : elle équivaut au courant continu qui produirait la même chaleur, et c'est celle qu'utilisent les multimètres, les fusibles et les plaques signalétiques. Le calcul suit son nom anglais : retire le point zéro de chaque échantillon, élève-le au carré (Square), fais la moyenne des carrés (Mean) puis prends la racine carrée (Root).

La durée de la fenêtre de mesure compte : si elle ne contient pas un nombre entier de périodes, le résultat varie un peu à chaque fois. Une période dure 20 ms à 50 Hz et 16,7 ms à 60 Hz. Une fenêtre de 100 ms contient exactement 5 périodes à 50 Hz et 6 à 60 Hz, elle fonctionne donc sur les deux réseaux, et l'Uno prend environ 900 échantillons pendant ce temps. Pour une sinusoïde pure, la crête vaut 1,414 fois la valeur efficace ; on pourrait donc aussi diviser la crête par √2. Mais des charges comme les chargeurs de téléphone, les ampoules LED ou les variateurs consomment des courants en pointes, non sinusoïdaux, et ce raccourci se trompe ; le programme ci-dessous calcule le vrai RMS et reste bien plus précis avec elles. La valeur crête doit rester dans la plage du modèle :

1// ACS712 ile AC akım (RMS) ve görünür güç / AC current (RMS) and apparent power with ACS712
2const int SENSOR_PIN = A0;
3const float SENSITIVITY = 0.100;      // 20A modül: 100 mV/A / 20A module: 100 mV/A
4const float ADC_STEP = 5.0 / 1024.0;
5const unsigned long WINDOW_MS = 100;  // 50 Hz'te 5, 60 Hz'te 6 tam periyot / 5 cycles at 50 Hz, 6 at 60 Hz
6const float MAINS_VOLTAGE = 230.0;    // şebeke gerilimi (V) / mains voltage (V)
7
8float noiseRms = 0.0;                 // yük yokken ölçülen gürültü (A) / noise measured with no load (A)
9
10// Pencere boyunca örnek alır, ortalamayı çıkarıp RMS hesaplar / samples over the window, removes the mean, returns RMS
11float readRmsAmps() {
12  long sum = 0;
13  unsigned long sumSq = 0;
14  unsigned int n = 0;
15  unsigned long start = millis();
16  while (millis() - start < WINDOW_MS) {
17    int d = analogRead(SENSOR_PIN) - 512;  // 2,5 V'u sıfıra yaklaştır / shift 2.5 V to about zero
18    sum += d;
19    sumSq += (long)d * d;
20    n++;
21  }
22  float mean = sum / (float)n;                       // sıfır noktası kayması / zero point offset
23  float variance = sumSq / (float)n - mean * mean;   // yalnız AC kısım / AC part only
24  if (variance < 0) variance = 0;
25  return sqrt(variance) * ADC_STEP / SENSITIVITY;
26}
27
28void setup() {
29  Serial.begin(9600);
30  delay(500);
31  noiseRms = readRmsAmps();           // ilk ölçüm yük KAPALIYKEN / first reading with the load OFF
32  Serial.print(F("Gurultu / Noise: "));
33  Serial.print(noiseRms, 3);
34  Serial.println(F(" A"));
35}
36
37void loop() {
38  float irms = readRmsAmps();
39  float sq = irms * irms - noiseRms * noiseRms;  // gürültüyü karesel çıkar / subtract noise in quadrature
40  irms = (sq > 0) ? sqrt(sq) : 0.0;
41  float apparentPower = MAINS_VOLTAGE * irms;     // VA; dirençli yükte ≈ W / VA; ≈ W for resistive loads
42
43  Serial.print(F("Irms: "));
44  Serial.print(irms, 3);
45  Serial.print(F(" A   Guc / Power: "));
46  Serial.print(apparentPower, 1);
47  Serial.println(F(" VA"));
48  delay(1000);
49}

Ce programme ne garde pas le point zéro sous forme de nombre fixe ; à chaque fenêtre, il calcule la moyenne des échantillons et la retire. Mathématiquement, c'est la racine carrée de la variance : RMS² = moyenne des carrés − carré de la moyenne. Comme un courant alternatif a une moyenne nulle sur un nombre entier de périodes, la moyenne trouvée est exactement l'erreur du point zéro, qui se corrige donc toute seule même si elle dérive avec la température. Le bruit mesuré au démarrage charge éteinte est retiré de façon quadratique, car le bruit et le vrai courant sont indépendants et les valeurs efficaces s'additionnent par leurs carrés. Sans cette étape, tu verrais des valeurs fantômes comme 0,1 A et 23 VA sans rien de branché. Un exemple : un fer à repasser de 1000 W consomme environ 4,35 A sous 230 V ; sa crête de 6,1 A dépasse la plage du modèle 5A, mesure-le donc avec le 20A.

Une méthode bien plus sûre pour mesurer le courant d'un appareil domestique est un transformateur de courant à noyau ouvrant comme le SCT-013, qui s'utilise sans couper aucun fil. Il se referme autour du câble comme une pince ampèremétrique et n'a aucun contact métallique avec le secteur. Le seul point à surveiller : la pince doit entourer uniquement la phase ou uniquement le neutre ; si tu entoures les deux conducteurs, les champs des courants opposés s'annulent et le résultat est nul. Les transformateurs de courant ne mesurent que l'alternatif ; pour le continu, il te faut l'ACS712 ou l'INA219.

Calculer la puissance (W) et l'énergie (Wh)

Une fois le courant connu, la puissance n'est qu'une multiplication : P = U × I. Si une batterie de 12 V alimente un moteur qui consomme 1,5 A, la puissance vaut 12 × 1,5 = 18 W ; tu peux le vérifier avec le calculateur de loi d'Ohm. L'énergie, c'est la puissance multipliée par le temps : si le moteur de 18 W tourne 2 heures, il consomme 36 Wh. Le programme le fait en multipliant à chaque mesure la puissance par le temps écoulé et en cumulant. Pour mesurer la tension, tu peux utiliser le module vendu comme capteur de tension 0–25 V ; il contient un pont diviseur de tension de 30 kΩ et 7,5 kΩ qui divise la tension d'entrée par 5. Pour concevoir un diviseur avec tes propres résistances, utilise le calculateur de pont diviseur.

1// ACS712 + gerilim sensörü ile güç (W) ve enerji (Wh) / power (W) and energy (Wh) with ACS712 + voltage sensor
2const int CURRENT_PIN = A0;           // ACS712 OUT
3const int VOLTAGE_PIN = A1;           // 0-25 V gerilim sensörü S pini / 0-25 V voltage sensor S pin
4const float SENSITIVITY = 0.185;      // 5A modül / 5A module (V/A)
5const float DIVIDER_RATIO = 5.0;      // (30k + 7,5k) / 7,5k = 5 / divider ratio
6const float ADC_STEP = 5.0 / 1024.0;
7const int SAMPLES = 200;
8
9float zeroRaw = 512.0;
10float energyWh = 0.0;                 // biriken enerji / accumulated energy
11unsigned long lastMs = 0;
12
13float averageRaw(int pin) {
14  long sum = 0;
15  for (int i = 0; i < SAMPLES; i++) sum += analogRead(pin);
16  return sum / (float)SAMPLES;
17}
18
19void setup() {
20  Serial.begin(9600);
21  delay(500);
22  zeroRaw = averageRaw(CURRENT_PIN);  // yük kapalıyken sıfır noktası / zero point with the load off
23  lastMs = millis();
24}
25
26void loop() {
27  float current = (averageRaw(CURRENT_PIN) - zeroRaw) * ADC_STEP / SENSITIVITY;
28  float voltage = averageRaw(VOLTAGE_PIN) * ADC_STEP * DIVIDER_RATIO;
29  float power = voltage * current;    // P = V x I (W)
30
31  unsigned long now = millis();
32  energyWh += power * (now - lastMs) / 3600000.0;  // W x saat = Wh / W x hours = Wh
33  lastMs = now;
34
35  Serial.print(voltage, 2);  Serial.print(F(" V   "));
36  Serial.print(current, 2);  Serial.print(F(" A   "));
37  Serial.print(power, 1);    Serial.print(F(" W   "));
38  Serial.print(energyWh, 3); Serial.println(F(" Wh"));
39  delay(1000);
40}

Comme le module de tension se branche entre le plus et le moins du circuit mesuré, cette fois le moins du circuit et le GND de l'Arduino doivent être reliés ; tu trouveras pourquoi dans notre guide sur la masse commune. Pour estimer combien d'heures tiendra une batterie, combine le courant moyen mesuré avec les calculs en mAh et Wh ou avec le calculateur d'autonomie de batterie. Côté alternatif, c'est un peu différent : Ueff × Ieff donne la puissance apparente, en VA ; la puissance active (W) est cette valeur multipliée par le facteur de puissance. Pour les charges résistives comme une bouilloire, un fer à repasser ou une ampoule à incandescence, le facteur de puissance est très proche de 1 et VA ≈ W. Pour les moteurs, adaptateurs et ampoules LED, il peut se situer entre 0,5 et 0,9 ; pour mesurer la vraie puissance active, il faut échantillonner en même temps la forme d'onde de la tension, avec des modules capteurs de tension isolés comme le ZMPT101B.

ACS712 avec ESP32 : lecture à travers un pont diviseur

L'ESP32 fonctionne en 3,3 V et ses entrées analogiques mesurent jusqu'à environ 3,1 V ; appliquer plus de 3,6 V sur une broche peut endommager la carte. L'ACS712, lui, ne fonctionne qu'en 5 V, et sa sortie peut atteindre 4,5 V sur les modèles 20A et 30A, et presque 5 V en surintensité. Tu alimentes donc le capteur depuis la broche 5V de la carte ESP32 (VIN sur certaines cartes) et tu fais passer OUT par un pont diviseur. 10 kΩ + 20 kΩ est un bon choix : de OUT à la broche de l'ESP32 à travers 10 kΩ, et de ce même point vers GND à travers 20 kΩ. Le rapport vaut 20 / 30 = 0,667, et les 30 kΩ au total respectent sans peine la charge minimale de 4,7 kΩ demandée par l'ACS712.

Le code comporte deux détails. D'abord, le CAN de l'ESP32 n'est pas linéaire aux extrémités ; au lieu des valeurs brutes, on utilise donc analogReadMilliVolts(), qui applique les données d'étalonnage écrites dans la puce en usine. Le GPIO 34 appartient à l'ADC1 et fonctionne Wi-Fi actif ; les broches de l'ADC2 ne sont pas utilisables avec le Wi-Fi. Ensuite, l'avantage ratiométrique de l'Uno n'existe pas ici : la référence du CAN de l'ESP32 est fixe, mais la sensibilité de l'ACS712 change avec les 5 V venant de l'USB. La solution est une astuce simple : comme la sortie vaut la moitié de VCC sans courant, tu multiplies par 2 le point zéro mesuré au démarrage pour obtenir la vraie tension d'alimentation du capteur, puis tu corriges la sensibilité en conséquence. Comme la même erreur se retrouve dans le point zéro et dans le signal mesuré, cette méthode compense aussi la tolérance des résistances du diviseur. Le programme échantillonne pendant 100 ms et renvoie deux résultats : regarde le premier pour une charge en continu et le second pour un appareil sur secteur.

1// ESP32 + ACS712 (10k/20k gerilim bölücüyle) / ESP32 + ACS712 (with a 10k/20k voltage divider)
2const int SENSOR_PIN = 34;            // ADC1_CH6, Wi-Fi açıkken de çalışır / works while Wi-Fi is on
3const float DIVIDER = 20.0 / 30.0;    // R2 / (R1 + R2) = 20k / 30k
4const float SENS_AT_5V = 185.0;       // mV/A: 5A=185, 20A=100, 30A=66
5const unsigned long WINDOW_MS = 100;  // 50 Hz'te 5 tam periyot / 5 full cycles at 50 Hz
6
7float zeroMv = 2500.0;                // akım yokken sensör çıkışı (mV) / sensor output at zero current (mV)
8float sensMv = SENS_AT_5V;            // düzeltilmiş hassasiyet (mV/A) / corrected sensitivity (mV/A)
9
10// Bölücüden önceki gerilimin ortalaması (mV) / average voltage before the divider (mV)
11float averageMv(int samples) {
12  uint32_t sum = 0;
13  for (int i = 0; i < samples; i++) sum += analogReadMilliVolts(SENSOR_PIN);
14  return sum / (float)samples / DIVIDER;
15}
16
17// Pencere boyunca okur: DC (ortalama) ve AC (RMS) akım / reads over the window: DC (mean) and AC (RMS) current
18void measure(float &dcAmps, float &acAmps) {
19  double sum = 0, sumSq = 0;
20  uint32_t n = 0;
21  uint32_t start = millis();
22  while (millis() - start < WINDOW_MS) {
23    double d = analogReadMilliVolts(SENSOR_PIN) / DIVIDER - zeroMv;
24    sum += d;
25    sumSq += d * d;
26    n++;
27  }
28  double mean = sum / n;
29  double variance = sumSq / n - mean * mean;
30  if (variance < 0) variance = 0;
31  dcAmps = mean / sensMv;
32  acAmps = sqrt(variance) / sensMv;
33}
34
35void setup() {
36  Serial.begin(115200);
37  analogReadResolution(12);
38  delay(500);
39  zeroMv = averageMv(1000);                    // yük KAPALIYKEN / with the load OFF
40  sensMv = SENS_AT_5V * (2.0 * zeroMv) / 5000.0;  // oransal düzeltme: VCC = 2 x sıfır / ratiometric fix: VCC = 2 x zero
41  Serial.printf("Sifir / Zero: %.0f mV  Hassasiyet / Sensitivity: %.1f mV/A\n", zeroMv, sensMv);
42}
43
44void loop() {
45  float dc, ac;
46  measure(dc, ac);
47  Serial.printf("DC: %.2f A   AC (RMS): %.2f A\n", dc, ac);
48  delay(1000);
49}

ACS712 avec Raspberry Pi Pico et MicroPython

Le Raspberry Pi Pico fonctionne lui aussi en 3,3 V, le câblage est donc le même que pour l'ESP32 : relie VCC de l'ACS712 à VBUS (broche 40), qui fournit 5 V quand le Pico est alimenté en USB, et OUT à GP26 (ADC0, broche 31) à travers le même diviseur 10k/20k. En MicroPython, read_u16() renvoie une valeur de 0 à 65535, et tension = brut × 3,3 / 65535. Le CAN du Pico est sur 12 bits ; avec le diviseur, il mesure en théorie par pas d'environ 6,5 mA sur le modèle 5A, soit environ quatre fois plus finement que l'Uno. Le code ci-dessous mesure le point zéro au démarrage, applique la correction ratiométrique, puis affiche chaque seconde le courant continu et la valeur efficace du courant alternatif.

1from machine import ADC
2import time
3import math
4
5adc = ADC(26)            # GP26 = ADC0, fiziksel pin 31 / physical pin 31
6VREF = 3.3               # ADC referansı (V) / ADC reference (V)
7DIVIDER = 20 / 30        # 10k/20k bölücü oranı / 10k/20k divider ratio
8SENS_AT_5V = 0.185       # V/A: 5A=0.185, 20A=0.100, 30A=0.066
9
10
11def read_volts(samples=200):
12    # bölücüden önceki ortalama gerilim / average voltage before the divider
13    total = 0
14    for _ in range(samples):
15        total += adc.read_u16()          # 0-65535
16    return total / samples * VREF / 65535 / DIVIDER
17
18
19zero = read_volts(1000)                  # yük KAPALIYKEN / with the load OFF
20sens = SENS_AT_5V * (2 * zero) / 5.0     # oransal düzeltme / ratiometric correction
21print("Sifir / Zero: {:.3f} V".format(zero))
22
23
24def read_rms(window_ms=100):
25    # 100 ms = 50 Hz'te 5 periyot / 5 cycles at 50 Hz
26    n = 0
27    s = 0.0
28    s2 = 0.0
29    start = time.ticks_ms()
30    while time.ticks_diff(time.ticks_ms(), start) < window_ms:
31        v = adc.read_u16() * VREF / 65535 / DIVIDER - zero
32        s += v
33        s2 += v * v
34        n += 1
35    mean = s / n
36    return math.sqrt(max(s2 / n - mean * mean, 0)) / sens
37
38
39while True:
40    dc = (read_volts() - zero) / sens
41    print("DC: {:.2f} A   AC (RMS): {:.2f} A".format(dc, read_rms()))
42    time.sleep(1)

ACS712 ou INA219 ?

L'INA219 est une puce de mesure de courant et de tension de Texas Instruments qui communique en I2C. Au lieu de l'effet Hall, elle mesure la chute de tension aux bornes d'une petite résistance shunt (en général 0,1 Ω sur les modules) traversée par le courant. Les modules courants mesurent jusqu'à ±3,2 A avec une résolution d'environ 0,8 mA, lisent eux-mêmes la tension du bus jusqu'à 26 V et calculent la puissance dans la puce. Avec une seule liaison I2C, tu obtiens donc tension, courant et puissance, sans te soucier du CAN, de la moyenne ou de l'étalonnage du zéro. En revanche, il n'y a pas d'isolation entre le circuit mesuré et l'Arduino, il ne mesure pas le courant alternatif et ne dépasse pas 26 V.

1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219;               // varsayılan adres 0x40 / default address 0x40
5
6void setup() {
7  Serial.begin(9600);
8  if (!ina219.begin()) {
9    Serial.println(F("INA219 bulunamadi / INA219 not found"));
10    while (true) delay(10);
11  }
12  // ina219.setCalibration_16V_400mA();  // küçük akımda daha ince çözünürlük / finer resolution for small currents
13}
14
15void loop() {
16  float busV = ina219.getBusVoltage_V();        // yük tarafındaki gerilim / voltage on the load side
17  float current_mA = ina219.getCurrent_mA();    // akım (mA) / current (mA)
18  float power_mW = ina219.getPower_mW();        // güç (mW) / power (mW)
19
20  Serial.print(busV, 2);       Serial.print(F(" V   "));
21  Serial.print(current_mA, 1); Serial.print(F(" mA   "));
22  Serial.print(power_mW, 0);   Serial.println(F(" mW"));
23  delay(1000);
24}

Pour le code, installe la bibliothèque Adafruit INA219 depuis le gestionnaire de bibliothèques. Relie SDA et SCL du module à A4 et A5 sur l'Uno ; le courant mesuré doit entrer par VIN+ et ressortir par VIN− vers la charge, et le GND de l'INA219 doit être commun avec le circuit mesuré. En bref : pour mesurer un courant continu de quelques milliampères à 3 A avec sa tension, choisis l'INA219 ; si tu as besoin de courants plus forts, d'alternatif ou d'isolation, l'ACS712 est le bon choix.

Idées de projets avec l'ACS712

• Protection d'un moteur contre les surintensités : quand un moteur à courant continu piloté par un L298N se bloque, son courant s'envole ; arrête le moteur et déclenche une alarme dès que ton seuil est dépassé.
• Moniteur de batterie et de panneau solaire : mesure le courant de charge et de décharge avec son sens, multiplie-le par la tension, cumule les Wh et affiche le tout sur un écran OLED.
• Prise connectée : commande la prise avec un module relais, vérifie avec l'ACS712 que l'appareil fonctionne vraiment et envoie les données à Home Assistant via MQTT.
• Alerte fin de lessive : quand le courant reste quelques minutes sous une valeur donnée, l'ESP32 t'envoie un message sur Telegram.
• Alarme de pompe à sec : quand l'eau manque, le courant de la pompe chute ; détecte-le et coupe la pompe.
• Enregistreur d'énergie : écris le courant et la puissance chaque minute sur une carte SD ou dans Google Sheets et trace la consommation journalière.
• Wattmètre d'atelier : ajoute un ACS712 au projet de voltmètre Arduino pour fabriquer un instrument qui affiche tension, courant et puissance sur un seul écran.

Erreurs fréquentes et solutions

L'ACS712 est un excellent point de départ pour apprendre à mesurer un courant : avec une seule broche analogique, tu mesures le courant continu et alternatif, et avec quelques lignes de code, la puissance et l'énergie. Si tu choisis le bon modèle, mesures le point zéro, fais la moyenne et étalonnes avec un multimètre, tu obtiendras des résultats fiables à quelques pour cent près. Tu peux consolider les bases de la lecture analogique dans notre guide sur le CAN. Dans l'application BlueGrays, tu trouveras des projets comme la lecture de capteurs analogiques, un voltmètre numérique avec écran LCD, la commande d'une ampoule secteur par relais et un enregistreur de données ESP32, chacun avec son schéma et son code pas à pas.