Sensor Arus ACS712: Mengukur Arus DC dan AC dengan Arduino

Sensor arus ACS712 adalah modul kecil dan murah yang mendeteksi arus yang mengalir di sebuah rangkaian dengan efek Hall lalu mengubahnya menjadi tegangan yang bisa dibaca Arduino-mu. Tanpa arus, output-nya berada di sekitar 2,5 V; nilainya naik ketika arus mengalir ke satu arah dan turun ketika arus mengalir ke arah sebaliknya. Artinya, kamu bisa mengukur arus searah (DC) maupun arus bolak-balik (AC) hanya dengan satu pin analog. Modul ini dipakai untuk melihat berapa arus yang ditarik motor, memantau baterai ketika sedang dikosongkan, mendeteksi apakah sebuah perangkat sedang menyala, atau menghitung berapa daya yang dipakai sebuah peralatan di rumah. Selain itu, jalur arus yang diukur terisolasi secara listrik dari sisi Arduino.

Di panduan ini kamu akan belajar langkah demi langkah apa isi ACS712, apa beda model 5A, 20A, dan 30A serta mana yang harus dipilih, cara memasang modul secara seri dengan rangkaianmu, sketch Arduino pertama yang mengukur arus DC, cara menenangkan pembacaan yang melompat-lompat dengan rata-rata, cara menghitung RMS untuk arus AC, dan cara menghitung daya (W) serta energi (Wh). Setelah itu kamu akan melihat cara menghubungkannya ke ESP32 dan Raspberry Pi Pico yang bekerja di 3,3 V lewat pembagi tegangan, kenapa kamu harus sangat berhati-hati dengan tegangan listrik PLN, dan kenapa INA219 adalah pilihan yang lebih baik untuk arus kecil.

Apa itu sensor arus ACS712 dan bagaimana cara kerjanya?

ACS712 adalah chip 8 kaki buatan Allegro. Arus yang diukur melewati jalur tembaga tebal di dalam chip, dari kaki 1 dan 2 ke kaki 3 dan 4. Hambatan jalur ini hanya 1,2 mΩ; bahkan pada 10 A tegangan yang jatuh hanya 12 mV dan panas yang dihasilkan 0,12 W, jadi hampir tidak memengaruhi rangkaian yang kamu ukur. Ketika arus mengalir lewat konduktor ini, terbentuk medan magnet yang sebanding dengan arusnya. Sensor Hall yang berada tepat di atas jalur tembaga menangkap medan tersebut, dan penguat di dalam chip mengubahnya menjadi tegangan. Kamu bisa membaca dasar-dasarnya lebih lanjut di panduan sensor efek Hall kami.

Tidak ada sambungan listrik antara jalur tembaga yang dialiri arus dan sisi yang memberi daya ke chip; satu-satunya penghubung di antara keduanya adalah medan magnet. Itulah sebabnya jalur yang diukur dan Arduino terisolasi satu sama lain (isolasi galvanik). Tegangan output mengikuti rumus ini: Vout = VCC / 2 + Sensitivitas × I. Jika arus mengalir dari IP+ ke IP−, output naik di atas 2,5 V; jika mengalir ke arah sebaliknya, output turun di bawahnya. ACS712 juga bersifat rasiometrik (ratiometric): titik nol maupun sensitivitasnya ikut berubah sesuai tegangan suplai. Jika suplai turun ke 4,8 V, titik nol menjadi 2,4 V dan sensitivitas model 5A turun dari 185 ke sekitar 178 mV/A.

Model 5A, 20A, dan 30A: sensitivitas dan resolusi

ACS712 hadir dalam tiga versi yang dari luar terlihat persis sama. Untuk mengetahui mana yang kamu punya, baca tulisan pada chip: ELC-05B mengukur ±5 A, ELC-20A ±20 A, dan ELC-30A ±30 A. Sensitivitas menunjukkan berapa milivolt output berubah untuk setiap 1 A arus. Makin besar rentangnya, makin rendah sensitivitasnya, sehingga pada model 20A dan 30A output tetap berada di antara 0,5 dan 4,5 V bahkan pada arus penuh. Tabel di bawah juga menunjukkan berapa miliampere yang diwakili satu langkah ADC 10-bit milik Uno (4,88 mV) pada tiap model.

Ada dua kesimpulan penting dari tabel ini. Pertama, derau yang dinyatakan dalam ampere sekitar 0,1 A pada ketiga model; kalau kamu memakai model 30A untuk beban 2 A, kamu membuang dua pertiga resolusimu. Aturannya sederhana: pilih model terkecil yang dengan aman mencakup arus tertinggi yang akan kamu ukur (nilai puncak untuk AC). Misalnya, model 5A cocok untuk motor DC 12 V yang menarik paling banyak 2–3 A, dan model 20A cocok untuk pemanas 1500 W. Kedua, ACS712 tidak dirancang untuk arus kecil: kamu tidak bisa mengukur LED yang menarik beberapa miliampere atau ESP32 dalam deep sleep dengannya. Untuk pekerjaan itu, INA219 yang dibahas di akhir panduan ini jauh lebih baik.

Pengkabelan ACS712: Arduino Uno, ESP32, dan Pico

Modul ACS712 punya dua sisi. Sisi terminal sekrup adalah milik rangkaian yang diukur: arus harus masuk lewat satu terminal dan keluar lewat terminal lainnya, jadi modul dipasang seri dengan beban, persis seperti amperemeter. Biasanya kamu memotong kabel positif dari catu daya, lalu menghubungkan ujung yang datang dari catu daya ke satu sisi terminal dan ujung yang menuju beban ke sisi lainnya. Sisi tiga pin menuju Arduino. ACS712 hanya bekerja di 5 V; pada ESP32 dan Pico kamu juga memberi daya ke modul dari pin yang menyediakan 5 V dan membaca output-nya lewat pembagi tegangan.

Selain chip, hanya ada sedikit komponen di modul: kapasitor decoupling di jalur suplai, kapasitor kecil di pin FILTER yang menentukan bandwidth, LED power (D1), dan resistornya (R1). Angka 102 yang tercetak di R1 berarti 1 kΩ; kamu bisa membaca kode seperti ini dengan mudah memakai dekoder kode SMD. Karena ACS712 terisolasi, kamu tidak perlu menghubungkan negatif rangkaian yang diukur ke GND Arduino jika hanya mengukur arus.

Langkah demi langkah: mengukur arus DC dengan Arduino

1. Hubungkan pin VCC modul ke pin 5V Arduino, GND ke GND, dan OUT ke A0. LED power di board seharusnya menyala.
2. Potong kabel positif rangkaian yang ingin kamu ukur: hubungkan ujung yang datang dari catu daya ke satu sisi terminal dan ujung yang menuju beban (mis. motor 12 V atau LED strip) ke sisi lainnya.
3. Biarkan catu daya beban dalam keadaan mati lalu upload sketch di bawah. Ketika mulai berjalan, sketch mengukur titik nol selagi belum ada arus yang mengalir.
4. Buka Serial Monitor pada 9600 baud; tanpa arus, nilainya seharusnya tetap di sekitar 0,00 A dan paling banyak bergoyang beberapa perseratus ampere.
5. Nyalakan catu daya beban. Jika arus tampil negatif, tukar posisi kedua kabel di terminal atau kalikan hasilnya dengan −1.
6. Atur SENSITIVITY di kode sesuai modelmu: 0.185 untuk 5A, 0.100 untuk 20A, dan 0.066 untuk 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}

Untuk setiap pembacaan, sketch merata-ratakan 200 hasil analogRead; karena satu analogRead memakan sekitar 0,11 ms di Uno, totalnya kira-kira 22 ms. Arus dihitung dengan I = (raw − nol) × (5 / 1024) / sensitivitas. Misalnya, pada model 5A dengan titik nol 512, rata-rata pembacaan 550 berarti selisih 38 langkah; itu sama dengan 38 × 4,88 mV = 185,5 mV, jadi arusnya 185,5 / 185 ≈ 1,00 A. Penting untuk mengukur titik nol ketika mulai berjalan alih-alih menganggapnya 2,5 V, karena offset chip itu sendiri dan perbedaan kecil di jalur ground board menggesernya beberapa langkah, dan error itu ikut ditambahkan ke setiap pembacaan.

Derau dan rata-rata

Output ACS712 terus bergetar bahkan ketika arusnya stabil. Penyebab pertama adalah derau sensor Hall itu sendiri: produsen mencantumkan angka derau di atas dengan kapasitor 47 nF di pin FILTER, yang berarti bandwidth sekitar 2 kHz. Namun sebagian besar modul memakai 1 nF di sana, seperti di rangkaian contoh dari produsen; bandwidth naik menjadi 80 kHz dan deraunya beberapa kali lebih besar. Penyebab kedua adalah ADC: bahkan pada model 5A, Uno mengukur dalam langkah 26 mA, dan langkah terakhir selalu berkedip naik-turun. Derau acak mengecil sebanding dengan akar kuadrat jumlah sampel yang dirata-ratakan: 16 sampel memangkasnya menjadi seperempat, 256 sampel menjadi seperenam belas. Untuk metode penyaringan lain, lihat panduan kami tentang menyaring data sensor.

• Rata-rata banyak sampel: Untuk DC, rata-ratakan 100–500 sampel. Jika kamu menyebar sampel selama 20 ms, interferensi 50 Hz dari listrik PLN juga saling meniadakan di dalam rata-rata.
• Rata-rata bergerak eksponensial: Campurkan setiap pembacaan baru ke nilai lama dengan terfilter = terfilter + 0,1 × (baru − terfilter); cara ini hampir tidak memakai memori dan memberi nilai yang tenang di layar.
• Zona mati (dead band): Jika kamu tidak ingin melihat nilai seperti 0,03 A ketika tidak ada yang terhubung, anggap hasil yang nilai mutlaknya di bawah 0,05 A sebagai 0.
• Filter hardware: Jika kamu bisa menyolder, tambahkan kapasitor 47 nF paralel dengan kapasitor di pin FILTER untuk menurunkan bandwidth ke sekitar 2 kHz; itu lebih dari cukup untuk DC dan arus listrik PLN 50 Hz.
• Jauhkan dari medan magnet: ACS712 adalah sensor Hall; magnet, speaker, atau kabel lain yang membawa arus besar di dekatnya akan menggeser pembacaan.
• Perbarui titik nol: Titik nol bergeser beberapa milivolt karena suhu; pada proyek yang berjalan lama, ukur ulang titik nol ketika beban mati.

Rata-rata menghilangkan derau tetapi tidak memperbaiki error sistematis. Sensitivitas bisa berbeda beberapa persen dari chip ke chip; pada model 5A nilainya antara 180 dan 190 mV/A. Untuk akurasi terbaik, pasang multimeter pada rentang arus secara seri di jalur yang sama dengan ACS712, alirkan arus yang sudah diketahui, misalnya 1–2 A, lalu bandingkan kedua nilainya. Jika multimeter menunjukkan 2,00 A dan Arduino 1,94 A, faktor koreksimu adalah 2,00 / 1,94 = 1,031; bagi SENSITIVITY di kode dengan angka ini (0.185 / 1.031 ≈ 0.179) dan pembacaanmu akan cocok dengan multimeter.

Mengukur arus AC: perhitungan RMS

Arus listrik rumah terus berubah arah: frekuensinya 50 Hz di Eropa, Indonesia, dan sebagian besar dunia, serta 60 Hz di AS. Itulah sebabnya output ACS712 membentuk gelombang sinus di sekitar 2,5 V yang rata-ratanya sesuai dengan arus nol; jika kamu menjalankan sketch DC pada beban AC, kamu akan mendapat nilai tak bermakna yang mendekati 0 A. Besaran yang penting untuk AC adalah nilai RMS (efektif): nilainya sama dengan arus DC yang menghasilkan panas yang sama, dan nilai inilah yang dipakai multimeter, sekring, dan label peralatan. Perhitungannya mengikuti namanya: kurangi setiap sampel dengan titik nol, kuadratkan (Square), rata-ratakan kuadratnya (Mean), lalu ambil akar kuadratnya (Root).

Panjang jendela pengukuran itu penting; jika jendela tidak berisi jumlah siklus yang bulat, hasilnya sedikit berubah setiap kali. Satu siklus berlangsung 20 ms pada 50 Hz dan 16,7 ms pada 60 Hz. Jendela 100 ms berisi tepat 5 siklus pada 50 Hz dan tepat 6 siklus pada 60 Hz, jadi bekerja dengan benar di kedua jaringan listrik, dan Uno mengambil sekitar 900 sampel dalam waktu itu. Untuk gelombang sinus murni, nilai puncak adalah 1,414 kali nilai RMS, jadi kamu juga bisa membagi nilai puncak dengan √2. Namun beban seperti charger ponsel, lampu LED, atau dimmer menarik arus yang runcing dan tidak sinusoidal, sehingga cara pintas itu salah pada beban tersebut; sketch di bawah menghitung true RMS, jadi jauh lebih akurat untuk beban seperti itu. Nilai puncak harus tetap berada dalam rentang model:

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}

Sketch ini tidak menyimpan titik nol sebagai angka tetap; di setiap jendela, sketch mencari rata-rata sampel lalu menguranginya. Secara matematis ini adalah akar kuadrat dari varians: RMS² = rata-rata kuadrat − kuadrat rata-rata. Karena rata-rata arus AC adalah nol dalam jumlah siklus yang bulat, rata-rata yang ditemukan tepat sama dengan error titik nol, dan sketch mengoreksinya sendiri bahkan ketika titik nol bergeser karena suhu. Derau yang diukur ketika mulai berjalan dengan beban mati dikurangkan secara kuadratik, karena derau dan arus yang sebenarnya saling independen dan nilai RMS dijumlahkan lewat kuadratnya. Tanpa langkah ini kamu akan melihat nilai hantu seperti 0,1 A dan 23 VA ketika tidak ada yang terhubung. Contoh: setrika 1000 W menarik sekitar 4,35 A pada 230 V; puncaknya 6,1 A melebihi rentang model 5A, jadi ukur dengan model 20A.

Cara yang jauh lebih aman untuk mengukur arus peralatan rumah tangga adalah trafo arus split-core (inti terbelah) seperti SCT-013, yang dipakai tanpa memotong kabel apa pun. Trafo ini dijepitkan di sekeliling kabel seperti tang ampere dan tidak pernah bersentuhan logam dengan listrik PLN. Satu-satunya yang perlu diperhatikan adalah penjepit hanya melingkari kabel fasa saja atau kabel netral saja; jika kamu menjepit keduanya sekaligus, medan dari arus yang berlawanan arah saling meniadakan dan hasilnya nol. Trafo arus hanya mengukur AC; untuk DC kamu perlu ACS712 atau INA219.

Menghitung daya (W) dan energi (Wh)

Begitu kamu tahu arusnya, daya cukup dihitung dengan satu perkalian: P = V × I. Jika baterai 12 V menyuplai motor yang menarik 1,5 A, dayanya 12 × 1,5 = 18 W; kamu bisa mengeceknya lagi dengan kalkulator hukum Ohm. Energi adalah daya dikali waktu: jika motor 18 W berjalan selama 2 jam, energi yang dipakainya 36 Wh. Sketch melakukan ini dengan mengalikan daya dengan waktu yang berlalu di setiap pembacaan lalu menjumlahkannya. Untuk mengukur tegangan, kamu bisa memakai modul yang dijual sebagai sensor tegangan 0–25 V; di dalamnya ada pembagi tegangan 30 kΩ dan 7,5 kΩ yang membagi tegangan input dengan 5. Jika ingin merancang pembagi dengan nilai resistor sendiri, pakai kalkulator pembagi tegangan.

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}

Karena modul tegangan dipasang di antara positif dan negatif rangkaian yang diukur, kali ini negatif rangkaian dan GND Arduino harus disatukan; kamu bisa mengetahui alasannya di panduan ground bersama kami. Untuk memperkirakan berapa jam sebuah baterai akan bertahan, gabungkan arus rata-rata yang kamu ukur dengan perhitungan mAh dan Wh atau kalkulator umur baterai. Di sisi AC, keadaannya sedikit berbeda: Vrms × Irms adalah daya semu yang diukur dalam VA; daya nyata (W) adalah nilai itu dikali faktor daya. Untuk beban resistif seperti ketel listrik, setrika, dan lampu pijar, faktor dayanya sangat dekat dengan 1, jadi VA ≈ W. Untuk motor, adaptor, dan lampu LED, nilainya bisa antara 0,5 dan 0,9; untuk mengukur daya nyata, kamu juga perlu menyampel bentuk gelombang tegangan pada waktu yang sama, dan itu dilakukan dengan modul sensor tegangan terisolasi seperti ZMPT101B.

ACS712 dengan ESP32: membaca lewat pembagi tegangan

ESP32 bekerja di 3,3 V dan input analognya bisa mengukur hingga sekitar 3,1 V; memberi lebih dari 3,6 V ke sebuah pin bisa merusak board. Di sisi lain, ACS712 hanya bekerja di 5 V, dan output-nya bisa mencapai 4,5 V pada model 20A dan 30A, bahkan hampir 5 V ketika terjadi arus lebih. Jadi kamu memberi daya ke sensor dari pin 5V board ESP32 (VIN di beberapa board) dan melewatkan OUT melalui pembagi tegangan. 10 kΩ + 20 kΩ adalah pilihan yang bagus: dari OUT lewat 10 kΩ ke pin ESP32, dan dari titik yang sama lewat 20 kΩ ke GND. Rasionya 20 / 30 = 0,667, dan total 30 kΩ dengan mudah memenuhi beban minimum ACS712 sebesar 4,7 kΩ.

Ada dua detail di kode. Pertama, ADC ESP32 tidak linear di dekat ujung-ujungnya, jadi alih-alih nilai raw kita memakai analogReadMilliVolts(), yang menerapkan data kalibrasi yang ditulis ke chip di pabrik. GPIO 34 ada di ADC1 dan tetap bekerja ketika Wi-Fi menyala; pin ADC2 tidak bisa dipakai bersamaan dengan Wi-Fi. Kedua, kemudahan rasiometrik seperti di Uno tidak ada di sini: referensi ADC ESP32 tetap, tetapi sensitivitas ACS712 berubah mengikuti 5 V yang datang dari USB. Solusinya trik sederhana: karena tanpa arus output sama dengan setengah VCC, kalikan titik nol yang diukur ketika mulai berjalan dengan 2 untuk mendapatkan tegangan suplai sensor yang sebenarnya, lalu koreksi sensitivitasnya sesuai nilai itu. Karena error yang sama ada di titik nol maupun di sinyal yang diukur, metode ini juga mengompensasi toleransi resistor pembagi. Sketch mengambil sampel selama 100 ms dan mengembalikan dua hasil sekaligus: lihat angka pertama untuk beban DC dan angka kedua untuk peralatan listrik PLN.

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 dengan Raspberry Pi Pico dan MicroPython

Raspberry Pi Pico juga bekerja di 3,3 V, jadi pengkabelannya sama seperti ESP32: hubungkan VCC ACS712 ke VBUS (pin 40), yang menyediakan 5 V ketika Pico diberi daya lewat USB, dan OUT lewat pembagi 10k/20k yang sama ke GP26 (ADC0, pin 31). Di MicroPython, read_u16() mengembalikan nilai dari 0 sampai 65535, dan tegangan = raw × 3,3 / 65535. ADC Pico 12-bit; bersama pembagi, di atas kertas ADC ini mengukur dalam langkah sekitar 6,5 mA pada model 5A, kira-kira empat kali lebih halus daripada Uno. Kode di bawah mengukur titik nol ketika mulai berjalan, menerapkan koreksi rasiometrik, lalu mencetak arus DC dan AC RMS setiap detik.

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 atau INA219?

INA219 adalah chip pemantau arus dan tegangan buatan Texas Instruments yang berkomunikasi lewat I2C. Alih-alih efek Hall, chip ini mengukur tegangan jatuh pada resistor shunt kecil (biasanya 0,1 Ω pada modul) yang dilewati arus. Modul yang populer mengukur hingga ±3,2 A dengan resolusi sekitar 0,8 mA, membaca sendiri tegangan bus hingga 26 V, dan menghitung daya di dalam chip. Jadi lewat satu koneksi I2C kamu mendapat tegangan, arus, dan daya sekaligus, tanpa repot dengan ADC, rata-rata, atau kalibrasi titik nol. Sebaliknya, chip ini tidak memberi isolasi antara rangkaian yang diukur dan Arduino, tidak bisa mengukur arus AC, dan tidak bisa dipakai di atas 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}

Untuk kodenya, instal library Adafruit INA219 dari Library Manager. Hubungkan pin SDA dan SCL modul ke A4 dan A5 di Uno; arus yang diukur harus masuk di VIN+ dan keluar dari VIN− menuju beban, dan GND INA219 harus disatukan dengan rangkaian yang diukur. Singkatnya: jika kamu mengukur arus DC dari beberapa miliampere hingga 3 A beserta tegangannya, pilih INA219; jika kamu butuh arus yang lebih besar, arus AC, atau isolasi, ACS712 adalah pilihan yang tepat.

Ide proyek dengan ACS712

• Proteksi arus lebih motor: Ketika motor DC yang dikendalikan L298N macet, arusnya melonjak; hentikan motor dan bunyikan alarm begitu ambang yang kamu tentukan terlampaui.
• Pemantau baterai dan panel surya: Ukur arus pengisian dan pengosongan beserta arahnya, kalikan dengan tegangan, akumulasikan Wh, lalu tampilkan hasilnya di layar OLED.
• Stopkontak pintar: Nyalakan dan matikan stopkontak dengan modul relay, pakai ACS712 untuk mengecek apakah peralatan benar-benar menyala, lalu kirim datanya ke Home Assistant lewat MQTT.
• Notifikasi mesin cuci selesai: Ketika arus tetap di bawah nilai tertentu selama beberapa menit, biarkan ESP32 mengirim pesan lewat bot Telegram.
• Alarm pompa berjalan kering: Ketika air habis, arus yang ditarik pompa turun; deteksi hal itu lalu matikan pompa.
• Pencatat energi: Tulis arus dan daya sekali per menit ke kartu SD atau Google Sheets lalu buat grafik konsumsi harian.
• Pengukur daya meja kerja: Tambahkan ACS712 ke proyek voltmeter Arduino untuk membuat alat ukur yang menampilkan tegangan, arus, dan daya di satu layar.

Kesalahan umum dan solusinya

ACS712 adalah cara yang bagus untuk mulai belajar mengukur arus: dengan satu pin analog kamu mengukur arus DC dan AC, dan dengan beberapa baris kode kamu juga mendapat daya dan energi. Jika kamu memilih model yang tepat, mengukur titik nol, merata-ratakan sampel, dan mengkalibrasi dengan multimeter, kamu akan mendapat hasil yang andal dengan selisih hanya beberapa persen. Kamu bisa memperkuat dasar pembacaan analog di panduan ADC kami. Di aplikasi BlueGrays kamu akan menemukan proyek seperti pembacaan sensor analog, voltmeter digital dengan layar LCD, mengendalikan bohlam listrik PLN dengan relay, dan pencatat data ESP32, masing-masing lengkap dengan skema rangkaian dan kode langkah demi langkah.