ACS712 Akım Sensörü: Arduino ve ESP32 ile DC ve AC Akım Ölçme

ACS712 akım sensörü, bir devreden geçen akımı Hall etkisiyle algılayıp Arduino'nun okuyabileceği bir gerilime çeviren küçük ve ucuz bir modüldür. Akım yokken çıkışı yaklaşık 2,5 V'tur; akım bir yönde aktıkça yükselir, ters yönde aktıkça düşer. Böylece hem doğru akımı (DC) hem de alternatif akımı (AC) tek bir analog pinle ölçebilirsin. Bir motorun ne kadar akım çektiğini görmek, akünün boşalmasını izlemek, bir cihazın çalışıp çalışmadığını anlamak ya da evdeki bir cihazın harcadığı gücü hesaplamak için kullanılır. Üstelik ölçülen akım hattı ile Arduino tarafı arasında elektriksel yalıtım vardır.

Bu yazıda ACS712'nin içinde ne olduğunu, 5A, 20A ve 30A modelleri arasındaki farkı ve hangisini seçmen gerektiğini, modülü devreye seri bağlamayı, Arduino ile DC akım ölçen ilk kodu, titreyen değerleri ortalamayla sakinleştirmeyi, AC akım için RMS hesabını ve güç (W) ile enerji (Wh) hesaplamayı adım adım öğreneceksin. Ardından 3,3 V ile çalışan ESP32 ve Raspberry Pi Pico'ya gerilim bölücüyle nasıl bağlanacağını, 220 V şebekede neden çok dikkatli olman gerektiğini ve küçük akımlar için daha iyi bir seçenek olan INA219'u göreceksin.

ACS712 akım sensörü nedir, nasıl çalışır?

ACS712, Allegro firmasının ürettiği 8 bacaklı bir yongadır. Ölçülen akım yonganın içindeki kalın bir bakır yoldan, 1 ve 2 numaralı bacaklardan 3 ve 4 numaralı bacaklara doğru geçer. Bu yolun direnci yalnızca 1,2 mΩ'dur; 10 A'de bile üzerinde 12 mV düşer ve 0,12 W ısı oluşur, yani ölçtüğün devreyi neredeyse hiç etkilemez. Akım bu iletkenden geçerken çevresinde akımla orantılı bir manyetik alan oluşur. Bakır yolun hemen üzerinde duran bir Hall sensörü bu alanı algılar, yonganın içindeki yükselteç de onu bir gerilime çevirir. Hall etkisinin temelini Hall etkisi sensörleri yazısında daha ayrıntılı bulabilirsin.

Akımın geçtiği bakır yol ile yonganın beslendiği taraf arasında elektriksel bir bağlantı yoktur; aradaki tek bağ manyetik alandır. Bu yüzden ölçülen hat ile Arduino birbirinden yalıtılmıştır (galvanik izolasyon). Çıkış gerilimi şu formülle bulunur: Vout = VCC / 2 + Hassasiyet × I. Akım IP+ ucundan IP− ucuna doğru akıyorsa çıkış 2,5 V'un üzerine çıkar, ters yönde akıyorsa altına iner. ACS712 ayrıca oransaldır (ratiometric): hem sıfır noktası hem de hassasiyet besleme gerilimiyle birlikte değişir. Besleme 4,8 V'a düşerse sıfır noktası 2,4 V olur ve 5A modelin hassasiyeti 185 yerine yaklaşık 178 mV/A'e iner.

5A, 20A ve 30A modelleri: hassasiyet ve çözünürlük

ACS712'nin üç sürümü vardır ve dışarıdan bakınca tıpatıp aynıdır. Hangisinin elinde olduğunu anlamak için yonganın üzerindeki yazıya bak: ELC-05B ±5 A, ELC-20A ±20 A, ELC-30A ±30 A ölçer. Hassasiyet, akım 1 A arttığında çıkışın kaç milivolt değiştiğini gösterir. Ölçüm aralığı büyüdükçe hassasiyet düşer; böylece 20A ve 30A modellerde en büyük akımda bile çıkış 0,5–4,5 V arasında kalır. Aşağıdaki tabloda Uno'nun 10 bitlik ADC'sinin bir basamağının (4,88 mV) her modelde kaç miliampere karşılık geldiğini de görebilirsin.

Tablodan iki önemli sonuç çıkar. Birincisi, gürültü üç modelde de akım cinsinden yaklaşık 0,1 A'dir; 30A modelini 2 A'lik bir yük için kullanırsan çözünürlüğün üçte ikisini boşa harcarsın. Kural basit: ölçeceğin en büyük akımı (AC'de tepe değerini) güvenle kapsayan en küçük modeli seç. Örneğin en fazla 2–3 A çeken 12 V'luk bir DC motor için 5A modeli, 1500 W'lık bir ısıtıcı için 20A modeli uygundur. İkincisi, ACS712 küçük akımlar için tasarlanmamıştır: birkaç miliamper çeken bir LED'i ya da uyku modundaki bir ESP32'yi bununla ölçemezsin. Bu iş için yazının sonunda anlatılan INA219 çok daha iyidir.

ACS712 bağlantısı: Arduino Uno, ESP32 ve Pico

ACS712 modülünün iki tarafı vardır. Vida klemensi tarafı ölçülen devreye aittir: akım bu iki uçtan birinden girip diğerinden çıkmalıdır, yani modül yüke tıpkı bir ampermetre gibi seri bağlanır. Genellikle güç kaynağının artı kablosunu keser, kaynaktan gelen ucu klemensin bir tarafına, yüke giden ucu diğer tarafına bağlarsın. Üç pinli taraf ise Arduino'ya gider. ACS712 yalnızca 5 V ile çalışır; ESP32 ve Pico'da da modülü 5 V veren pinden beslemen, çıkışı ise bir gerilim bölücüden geçirerek okuman gerekir.

Modülün üzerinde yongadan başka çok az parça vardır: besleme hattı için bir dekuplaj kondansatörü, FILTER pinine bağlı ve bant genişliğini belirleyen küçük bir kondansatör, güç LED'i (D1) ve onun direnci (R1). R1'in üzerindeki 102 yazısı 1 kΩ demektir; bu tür kodları SMD kod çözücü ile kolayca okuyabilirsin. ACS712 yalıtımlı olduğu için yalnızca akım ölçerken ölçülen devrenin eksisini Arduino'nun GND'sine bağlaman gerekmez.

Adım adım: Arduino ile DC akım ölçme

1. Modülün VCC pinini Arduino'nun 5V pinine, GND'yi GND'ye, OUT'u A0'a bağla. Kartın üzerindeki güç LED'i yanmalı.
2. Ölçmek istediğin devrenin artı kablosunu kes: güç kaynağından gelen ucu klemensin bir tarafına, yüke (ör. 12 V motor ya da şerit LED) giden ucu diğer tarafına bağla.
3. Yükün güç kaynağını kapalı tut ve aşağıdaki kodu yükle. Kod açılışta, akım yokken sıfır noktasını ölçer.
4. Seri Monitör'ü 9600 baud hızında aç; akım yokken değerin 0,00 A civarında kaldığını ve en fazla birkaç yüzde bir amper oynadığını gör.
5. Yükün güç kaynağını aç. Akım eksi çıkıyorsa klemensteki iki kabloyu yer değiştir ya da sonucu −1 ile çarp.
6. Koddaki SENSITIVITY değerini modeline göre ayarla: 5A için 0.185, 20A için 0.100, 30A için 0.066.

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}

Kod her ölçümde 200 analogRead sonucunun ortalamasını alır; Uno'da bir analogRead yaklaşık 0,11 ms sürdüğü için bu yaklaşık 22 ms eder. Akım I = (ham − sıfır) × (5 / 1024) / hassasiyet formülüyle bulunur. Örneğin 5A modelde sıfır noktası 512 iken ortalama 550 okursan fark 38 basamaktır; bu 38 × 4,88 mV = 185,5 mV eder ve akım 185,5 / 185 ≈ 1,00 A olur. Sıfır noktasını 2,5 V varsaymak yerine açılışta ölçmek önemlidir; çünkü yonganın kendi kayması ve kartın toprak hattındaki küçük farklar bu noktayı birkaç basamak oynatır ve bu hata her ölçüme eklenir.

Gürültü ve ortalama alma

ACS712'nin çıkışı akım sabitken bile durmadan titrer. İlk sebep Hall sensörünün kendi gürültüsüdür: üretici yukarıdaki gürültü değerlerini FILTER pininde 47 nF kondansatör, yani yaklaşık 2 kHz bant genişliği için verir. Modüllerin çoğunda ise burada üreticinin örnek devresindeki gibi 1 nF kondansatör vardır; bant genişliği 80 kHz'e çıkar ve gürültü birkaç kat artar. İkinci sebep ADC'dir: Uno 5A modelde bile 26 mA'lik basamaklarla ölçer ve son basamak her zaman bir aşağı bir yukarı oynar. Rastgele gürültü, ortalaması alınan örnek sayısının kareköküyle azalır: 16 örnek gürültüyü dörtte birine, 256 örnek on altıda birine indirir. Diğer filtre yöntemleri için sensör verisini filtreleme yazısına da bakabilirsin.

• Çok örnekli ortalama: DC ölçümde 100–500 örneğin ortalamasını al. Örnekleri 20 ms'lik bir süreye yayarsan şebekeden gelen 50 Hz'lik parazit de ortalamada kendini götürür.
• Üstel hareketli ortalama: Her yeni ölçümü filtre = filtre + 0,1 × (yeni − filtre) formülüyle eskisine karıştır; çok az bellek harcar ve ekranda sakin bir değer verir.
• Ölü bölge: Akım yokken ekranda 0,03 A gibi değerler görmek istemiyorsan, mutlak değeri 0,05 A'in altında kalan sonuçları 0 kabul et.
• Donanım filtresi: Lehim yapabiliyorsan FILTER pinindeki kondansatöre paralel bir 47 nF ekleyerek bant genişliğini yaklaşık 2 kHz'e indirebilirsin; DC ve 50 Hz'lik şebeke akımı için bu fazlasıyla yeterlidir.
• Manyetik alanlardan uzak dur: ACS712 bir Hall sensörüdür; yanındaki bir mıknatıs, hoparlör ya da üzerinden yüksek akım geçen başka bir kablo okumayı kaydırır.
• Sıfır noktasını yenile: Sıfır noktası sıcaklıkla birkaç milivolt kayar; uzun süre çalışan projelerde yük kapalıyken sıfırı yeniden ölç.

Ortalama almak gürültüyü giderir ama sistematik hatayı düzeltmez. Hassasiyet yongadan yongaya birkaç yüzde değişebilir; 5A modelde 180 ile 190 mV/A arasındadır. En doğru sonuç için multimetreyi akım kademesinde ACS712 ile aynı hatta seri bağla, 1–2 A gibi bilinen bir akım geçir ve iki değeri karşılaştır. Multimetre 2,00 A, Arduino 1,94 A gösteriyorsa düzeltme katsayın 2,00 / 1,94 = 1,031'dir; koddaki SENSITIVITY değerini bu sayıya böl (0,185 / 1,031 ≈ 0,179); böylece ölçümün multimetreyle örtüşür.

AC akım ölçme: RMS hesabı

Şebekedeki alternatif akım sürekli yön değiştirir; Türkiye ve Avrupa'da frekans 50 Hz, ABD'de 60 Hz'tir. Bu yüzden ACS712'nin çıkışı 2,5 V'un etrafında bir sinüs dalgası çizer ve ortalaması sıfır akıma karşılık gelir; DC kodunu AC bir yükte çalıştırırsan ekranda 0 A'e yakın, anlamsız değerler görürsün. AC'de anlamlı olan büyüklük RMS (etkin) değerdir: aynı ısıyı üreten DC akıma eşittir ve multimetrelerin, sigortaların ve cihaz etiketlerinin kullandığı değer budur. Hesap adındaki sırayı izler: her örnekten sıfır noktasını çıkar, karesini al (Square), karelerin ortalamasını bul (Mean) ve karekökünü al (Root).

Ölçüm penceresinin uzunluğu önemlidir; pencere tam sayıda periyot içermezse sonuç her seferinde biraz değişir. 50 Hz'te bir periyot 20 ms, 60 Hz'te 16,7 ms'dir. 100 ms'lik bir pencere 50 Hz'te tam 5, 60 Hz'te tam 6 periyot içerdiği için iki şebekede de doğru çalışır ve Uno bu sürede yaklaşık 900 örnek alır. Saf sinüste tepe değeri RMS'nin 1,414 katıdır, bu yüzden tepe değerini √2'ye bölerek de RMS bulunabilir. Ancak telefon şarj cihazı, LED ampul ya da dimmer gibi yükler sinüs olmayan sivri akımlar çektiği için bu kestirme yöntem yanılır; aşağıdaki kod gerçek RMS hesapladığı için bu yüklerde çok daha doğrudur. Tepe değeri modelin sınırını aşmamalıdır:

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}

Bu kod sıfır noktasını sabit bir sayı olarak saklamaz; her pencerede örneklerin ortalamasını bulur ve onu çıkarır. Matematikte bu varyansın kareköküdür: RMS² = karelerin ortalaması − ortalamanın karesi. AC akımın ortalaması tam sayıda periyotta sıfır olduğundan bulunan ortalama doğrudan sıfır noktası hatasıdır ve sıcaklıkla kaysa bile kendiliğinden düzeltilir. Açılışta yük kapalıyken ölçülen gürültü ise karesel olarak çıkarılır, çünkü gürültü ile gerçek akım birbirinden bağımsızdır ve RMS değerleri kareleriyle toplanır. Bu adım olmasa hiçbir şey bağlı değilken bile ekranda 0,1 A ve 23 VA gibi hayalet değerler görürdün. Bir örnek: 1000 W'lık bir ütü 230 V'ta yaklaşık 4,35 A çeker; tepe değeri 6,1 A olduğu için 5A modelin sınırını aşar ve 20A modelle ölçülmelidir.

Evdeki bir cihazın akımını ölçmenin çok daha güvenli yolu, kabloyu hiç kesmeden kullanılan SCT-013 gibi açılıp kapanan (ayrık çekirdekli) akım trafolarıdır. Pens ampermetre gibi kablonun etrafına takılırlar ve şebekeyle hiçbir metal temasları olmaz. Tek dikkat edilecek nokta pensin yalnızca faz ya da yalnızca nötr iletkenini sarmasıdır; iki iletkeni birlikte sararsan zıt yönlü akımların alanları birbirini yok eder ve sonuç sıfır çıkar. Akım trafoları yalnızca AC ölçer; DC için ACS712 ya da INA219 gerekir.

Güç (W) ve enerji (Wh) hesabı

Akımı bildiğinde gücü bulmak tek bir çarpmadır: P = V × I. 12 V'luk bir akü 1,5 A çeken bir motoru besliyorsa güç 12 × 1,5 = 18 W'tır; bu hesapları Ohm kanunu hesaplayıcısı ile de kontrol edebilirsin. Enerji ise gücün zamanla çarpımıdır: 18 W'lık motor 2 saat çalışırsa 36 Wh harcar. Kod bunu her ölçümde gücü geçen süreyle çarpıp toplayarak yapar. Gerilimi ölçmek için piyasada 0–25 V gerilim sensörü adıyla satılan modülü kullanabilirsin; içinde 30 kΩ ve 7,5 kΩ'luk bir gerilim bölücü vardır ve girişteki gerilimi 5'e böler. Kendi direnç değerlerinle bir bölücü tasarlamak istersen gerilim bölücü hesaplayıcısını kullan.

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}

Gerilim modülü ölçülen devrenin artısı ile eksisi arasına bağlandığı için bu kez devrenin eksisi ile Arduino'nun GND'si birleşmelidir; nedenini ortak toprak yazısında bulabilirsin. Bataryanın kaç saat dayanacağını tahmin etmek için ölçtüğün ortalama akımı mAh ve Wh hesaplarıyla ya da pil ömrü hesaplayıcısı ile birleştirebilirsin. AC tarafında iş biraz farklıdır: Vrms × Irms çarpımı görünür güçtür ve birimi VA'dır; gerçek güç (W) bunun güç faktörüyle çarpımıdır. Su ısıtıcısı, ütü ve akkor ampul gibi dirençli yüklerde güç faktörü 1'e çok yakındır ve VA ≈ W kabul edilebilir. Motorlarda, adaptörlerde ve LED ampullerde ise güç faktörü 0,5–0,9 arasında olabilir; gerçek gücü ölçmek için gerilimin dalga şeklini de aynı anda örneklemek gerekir ve bunun için ZMPT101B gibi yalıtımlı gerilim sensörü modülleri kullanılır.

ESP32 ile ACS712: gerilim bölücüyle okuma

ESP32 3,3 V ile çalışır ve analog girişleri en fazla yaklaşık 3,1 V'a kadar ölçebilir; pinlere 3,6 V'un üzerinde gerilim vermek kartı bozabilir. ACS712 ise yalnızca 5 V ile çalışır ve çıkışı 20A ile 30A modellerde 4,5 V'a, aşırı akımda neredeyse 5 V'a kadar çıkabilir. Bu yüzden sensörü ESP32 kartının 5V (bazı kartlarda VIN) pininden besler, OUT çıkışını ise bir gerilim bölücüden geçirirsin. 10 kΩ + 20 kΩ iyi bir seçimdir: OUT'tan 10 kΩ ile ESP32 pinine, aynı noktadan 20 kΩ ile GND'ye git. Bölme oranı 20 / 30 = 0,667 olur ve toplam 30 kΩ, ACS712'nin istediği en az 4,7 kΩ yük şartını da rahatça karşılar.

Kodda iki ayrıntı var. Birincisi, ESP32'nin ADC'si uçlarda doğrusal değildir; bu yüzden ham değer yerine, üretimde yongaya yazılan kalibrasyon verisini kullanan analogReadMilliVolts() fonksiyonunu kullanıyoruz. GPIO 34 ADC1 kanalındadır ve Wi-Fi açıkken de çalışır; ADC2 pinleri ise Wi-Fi ile birlikte kullanılamaz. İkincisi, Uno'daki oransal kolaylık burada yoktur: ESP32'nin ADC referansı sabittir ama ACS712'nin hassasiyeti USB'den gelen 5 V ile değişir. Çözüm basit bir hiledir: akım yokken çıkış VCC'nin yarısı olduğundan, açılışta ölçtüğün sıfır noktasını 2 ile çarparak sensörün gerçek besleme gerilimini bulur ve hassasiyeti buna göre düzeltirsin. Aynı hata hem sıfır noktasında hem de ölçülen sinyalde bulunduğu için bu yöntem bölücü dirençlerinin toleransını da telafi eder. Kod 100 ms boyunca örnek alır ve iki sonucu birlikte verir: DC bir yükte ilk sayıya, şebekedeki bir cihazda ikinci sayıya bak.

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}

Raspberry Pi Pico ve MicroPython ile ACS712

Raspberry Pi Pico da 3,3 V ile çalıştığı için bağlantı ESP32 ile aynıdır: ACS712'nin VCC pinini, Pico USB'den beslenirken 5 V veren VBUS (pin 40) pinine, OUT'u aynı 10k/20k bölücü üzerinden GP26'ya (ADC0, pin 31) bağla. MicroPython'da read_u16() sonucu 0–65535 aralığında verir ve gerilim = ham × 3,3 / 65535 olur. Pico'nun ADC'si 12 bittir; bölücüyle birlikte 5A modelde kâğıt üzerinde yaklaşık 6,5 mA'lik adımlarla ölçer, yani Uno'dan yaklaşık dört kat ince bir çözünürlük sunar. Aşağıdaki kod sıfır noktasını açılışta ölçer, oransal düzeltmeyi yapar, ardından her saniye DC ve AC RMS akımı yazdırır.

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 mi INA219 mu?

INA219, Texas Instruments'ın ürettiği ve I2C ile haberleşen bir akım ve gerilim ölçüm yongasıdır. Hall etkisi yerine, akımın geçtiği küçük bir şönt direnç (modüllerde genellikle 0,1 Ω) üzerindeki gerilim düşümünü ölçer. Popüler modüller ±3,2 A'e kadar yaklaşık 0,8 mA çözünürlükle ölçer, 26 V'a kadar hat gerilimini de kendisi okur ve gücü yonganın içinde hesaplar. Yani tek bir I2C bağlantısıyla gerilim, akım ve gücü birlikte alırsın; ADC, ortalama ya da sıfır kalibrasyonuyla uğraşmazsın. Buna karşılık ölçtüğü devre ile Arduino arasında yalıtım yoktur, AC akım ölçemez ve 26 V'un üzerine çıkamaz.

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}

Kod için Kütüphane Yöneticisi'nden Adafruit INA219 kütüphanesini kur. Modülün SDA ve SCL pinlerini Uno'da A4 ve A5'e bağla; ölçülecek akım VIN+ ucundan girip VIN− ucundan yüke çıkmalı ve INA219'un GND'si ölçülen devreyle ortak olmalıdır. Kısacası birkaç miliamperden 3 A'e kadar DC akım ve gerilim ölçeceksen INA219, daha büyük akımlar, AC akım ya da yalıtım gerekiyorsa ACS712 doğru seçimdir.

ACS712 ile proje fikirleri

• Motor aşırı akım koruması: L298N ile sürülen bir DC motor sıkışınca akım fırlar; belirlediğin eşik aşılınca motoru durdur ve sesli uyarı ver.
• Akü ve güneş paneli izleyici: Şarj ve deşarj akımını yönüyle birlikte ölç, gerilimle çarpıp Wh olarak biriktir ve sonuçları OLED ekranda göster.
• Akıllı priz: Prizi bir röle modülüyle aç kapa, ACS712 ile cihazın gerçekten çalışıp çalışmadığını izle ve verileri MQTT ile Home Assistant'a gönder.
• Çamaşır makinesi bitti bildirimi: Akım birkaç dakika boyunca belli bir değerin altında kalınca ESP32 Telegram'dan mesaj göndersin.
• Pompa kuru çalışma alarmı: Su bitince pompanın çektiği akım düşer; bunu algılayıp pompayı kapat.
• Enerji kaydedici: Akım ve güç değerlerini dakikada bir SD karta ya da Google E-Tablolar'a yaz ve günlük tüketim grafiğini çiz.
• Tezgâh güç ölçeri: Arduino voltmetre projesine ACS712 ekleyerek gerilimi, akımı ve gücü aynı ekranda gösteren bir ölçü aleti yap.

Sık yapılan hatalar ve çözümleri

ACS712, akım ölçmeyi öğrenmek için harika bir başlangıçtır: tek bir analog pinle DC ve AC akımı, birkaç satır kodla da gücü ve enerjiyi ölçersin. Doğru modeli seçer, sıfır noktasını ölçer, ortalama alır ve multimetreyle kalibre edersen birkaç yüzde içinde güvenilir sonuçlar alırsın. Analog okumanın temellerini ADC yazısında pekiştirebilirsin. BlueGrays uygulamasında analog sensör okuma, LCD ekranlı dijital voltmetre, röleyle 220 V ampul kontrolü ve ESP32 veri kaydedici gibi projeleri devre şemaları ve kodlarıyla adım adım bulabilirsin.