Tutorial INA219 Arduino: Mengukur Arus, Tegangan, dan Daya
Bagaimana cara menghubungkan sensor arus INA219 ke Arduino, ESP32, dan Pico? Shunt 0,1 Ω, batas 26 V/3,2 A, kalibrasi, pengukuran panel surya dan baterai, serta perbandingan dengan ACS712.
INA219 adalah cara paling praktis untuk mengukur arus, tegangan, dan daya sekaligus di proyek Arduino. Chip kecil buatan Texas Instruments ini menghitung secara digital arus yang melewati resistor shunt yang dipasang seri dengan rangkaianmu, tegangan di sisi beban, dan daya, yaitu hasil kali keduanya. Hasilnya dikirim hanya lewat dua kabel I2C. Modul yang umum dijual memakai shunt 0,1 Ω, dan dalam bentuk itu sensor bisa mengukur jalur dengan tegangan sampai 26 V dan arus sampai sekitar ±3,2 A dengan langkah kira-kira 0,1 mA.
Kalau kamu ingin tahu berapa daya yang dihasilkan panel surya sepanjang hari, berapa jam proyek ESP32 akan menghabiskan baterainya, atau berapa arus yang ditarik motor ketika berbeban, inilah sensor yang kamu cari. Di artikel ini kamu akan belajar langkah demi langkah cara kerja shunt, rentang pengukuran, hitungan kalibrasi, kode yang berjalan untuk Arduino Uno, ESP32, dan Raspberry Pi Pico, serta perbedaannya dengan ACS712.
Apa itu INA219 dan bagaimana cara kerjanya?
Dasar INA219 adalah hukum Ohm. Sebuah resistor presisi bernilai sangat kecil (shunt) dipasang di jalur arus; ketika arus mengalir melewatinya, muncul jatuh tegangan kecil yang sebanding dengan arus. Dengan shunt 0,1 Ω, arus 1 A menghasilkan 100 mV dan 250 mA menghasilkan 25 mV (V = I × R). Penguat berpenguatan terprogram (PGA) dan ADC 12-bit di dalam chip membaca tegangan orde milivolt ini lalu menyimpannya di register tegangan shunt dengan langkah 10 µV. Chip ini juga mengukur tegangan antara ujung shunt di sisi beban (Vin−) dan GND dengan resolusi 4 mV; ini disebut bus voltage atau tegangan jalur. Begitu nilai yang benar ditulis ke register kalibrasi, INA219 menghitung arus dan daya sendiri, jadi mikrokontroler tidak perlu melakukan perkalian atau pembagian apa pun. Karena shunt dipasang di antara positif catu daya dan beban, cara ini disebut pengukuran high-side, dan ground beban tidak terganggu. Arus diukur di dua arah: arus yang mengalir dari Vin+ ke Vin− bernilai positif, sedangkan arus di arah sebaliknya tampil negatif.
| Fitur | Nilai |
|---|---|
| Chip | Texas Instruments INA219 (versi A dan B) |
| Komunikasi | I2C / SMBus, mendukung fast mode 400 kHz |
| Catu daya (VCC) | 3,0–5,5 V |
| Tegangan jalur yang bisa diukur | 0–26 V (rentang register diatur 16 V atau 32 V) |
| Rentang tegangan shunt | ±40, ±80, ±160, atau ±320 mV (dipilih lewat PGA) |
| Shunt di modul | 0,1 Ω (bertanda R100) |
| Arus maksimum (dengan 0,1 Ω) | Sekitar ±3,2 A |
| ADC | 12-bit, waktu konversi 532 µs, rata-rata internal sampai 128 sampel |
| Akurasi | INA219B: galat maks. 0,5% di seluruh rentang suhu (1% untuk versi A) |
| Alamat I2C | 0x40 (0x41, 0x44, 0x45 dengan jembatan A0/A1) |
Resistor shunt dan rentang pengukuran
Arus maksimum yang bisa diukur INA219 ditentukan oleh nilai shunt dan pengaturan PGA: I_max = V_shunt,max / R_shunt. Di rentang sempit, tegangan kecil terbaca dengan galat lebih kecil, sedangkan rentang lebar memungkinkanmu menjangkau arus yang lebih besar. Daya yang dibuang shunt dihitung dengan P = I² × R: pada 3,2 A, shunt 0,1 Ω mengubah sekitar 1 W menjadi panas, dan jatuh tegangan 320 mV di atasnya juga mengurangi tegangan yang diterima beban. Untuk arus yang lebih besar, kamu bisa mengganti shunt dengan nilai lebih kecil seperti 0,01 Ω, tetapi jalur tembaga tipis dan terminal modul biasanya dirancang untuk sekitar 3 A. Untuk arus yang sangat kecil, shunt 1 Ω membuat langkahnya sepuluh kali lebih halus: 10 µV / 1 Ω = 10 µA. Dengan shunt 0,1 Ω bawaan modul, keempat pilihannya adalah:
| Pengaturan PGA | Rentang tegangan shunt | Arus maks. (0,1 Ω) | Kapan dipakai |
|---|---|---|---|
| /1 | ±40 mV | ±400 mA | Sensor, board mikrokontroler, rangkaian berarus rendah |
| /2 | ±80 mV | ±800 mA | LED strip pendek, satu motor servo |
| /4 | ±160 mV | ±1,6 A | Motor DC kecil, pompa mini |
| /8 (bawaan) | ±320 mV | ±3,2 A | Panel surya, motor, pemakaian umum |
Pengkabelan INA219: Arduino Uno, ESP32, dan Pico
| Pin INA219 | Arduino Uno | ESP32 | Raspberry Pi Pico | Fungsi |
|---|---|---|---|---|
| VCC | 5V | 3V3 | 3V3(OUT), pin 36 | Catu daya chip |
| GND | GND | GND | GND | Ground bersama (harus tersambung juga ke negatif beban) |
| SCL | A5 | GPIO 22 | GP5 (pin 7) | Jalur clock I2C |
| SDA | A4 | GPIO 21 | GP4 (pin 6) | Jalur data I2C |
| Vin+ | Positif catu daya | Positif catu daya | Positif catu daya | Tempat arus masuk |
| Vin− | Positif beban | Positif beban | Positif beban | Tempat arus keluar |
Bayangkan jalur arus sebagai sebuah rantai: positif catu daya, Vin+, shunt, Vin−, positif beban, negatif beban, dan akhirnya negatif catu daya. INA219 masuk ke rantai ini secara seri, persis seperti amperemeter. Negatif catu daya, negatif beban, dan pin GND modul harus disambung jadi satu; kalau tidak, pembacaan tegangan jalur tidak ada artinya meskipun arusnya terlihat benar (lihat artikel Ground Bersama (GND) untuk detailnya). Di Uno, kamu juga bisa memakai pin SDA/SCL di dekat pojok atas board sebagai ganti A4/A5; keduanya jalur yang sama. Sebagian besar modul sudah dilengkapi resistor pull-up I2C, jadi tidak perlu resistor tambahan. Di ESP32 dan Pico, kalau modul diberi daya dari 3V3, pull-up tersebut juga menarik ke 3,3 V sehingga pin-mu tetap aman.
Langkah demi langkah: pengukuran pertama dengan Arduino Uno
- Buka Library Manager di Arduino IDE, cari library Adafruit INA219, dan setujui dependensi Adafruit BusIO ketika diminta. Kalau kamu belum pernah menginstal library, lihat Cara Instal Library Arduino.
- Hubungkan pin VCC, GND, SDA, dan SCL modul ke Uno seperti di tabel.
- Pilih beban yang ingin diukur: misalnya LED merah dengan resistor 220 Ω pada baterai 9 V, atau motor DC kecil. Hubungkan positif baterai ke Vin+ dan Vin− ke positif beban.
- Hubungkan negatif baterai ke negatif beban sekaligus ke pin GND INA219, supaya Uno, baterai, dan beban memakai ground bersama.
- Upload kodenya, buka Serial Monitor di 115200 baud, lalu bandingkan arus yang terbaca dengan multimeter yang dipasang seri.
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(115200);
8 if (!ina219.begin()) { // sensörü ve I2C'yi başlat / start sensor and I2C
9 Serial.println(F("INA219 bulunamadi / INA219 not found"));
10 while (1) { delay(10); }
11 }
12 // ina219.setCalibration_32V_1A(); // daha ince adım / finer steps
13 // ina219.setCalibration_16V_400mA(); // küçük akımlar / small currents
14 Serial.println(F("INA219 hazir / ready"));
15}
16
17void loop() {
18 float shunt_mV = ina219.getShuntVoltage_mV(); // şönt üzerindeki gerilim / voltage across the shunt
19 float bus_V = ina219.getBusVoltage_V(); // Vin- ile GND arası / Vin- to GND
20 float current_mA = ina219.getCurrent_mA(); // akım / current
21 float power_mW = ina219.getPower_mW(); // güç / power
22 float source_V = bus_V + shunt_mV / 1000.0; // kaynak gerilimi / source voltage
23
24 Serial.print(F("Kaynak: ")); Serial.print(source_V, 2); Serial.print(F(" V "));
25 Serial.print(F("Yuk: ")); Serial.print(bus_V, 2); Serial.print(F(" V "));
26 Serial.print(F("Sont: ")); Serial.print(shunt_mV, 2); Serial.print(F(" mV "));
27 Serial.print(F("Akim: ")); Serial.print(current_mA, 1); Serial.print(F(" mA "));
28 Serial.print(F("Guc: ")); Serial.print(power_mW, 0); Serial.println(F(" mW"));
29 delay(1000);
30}| Fungsi | Nilai yang dikembalikan |
|---|---|
| ina219.begin() | Mengembalikan true jika sensor ditemukan; juga memulai bus I2C |
| getShuntVoltage_mV() | Tegangan di atas shunt (mV) |
| getBusVoltage_V() | Tegangan antara Vin− dan GND, yaitu tegangan yang diterima beban (V) |
| getCurrent_mA() | Arus yang dihitung dari kalibrasi (mA), negatif di arah sebaliknya |
| getPower_mW() | Hasil kali arus dan tegangan jalur (mW) |
| bus_V + shunt_mV / 1000 | Tegangan sumber itu sendiri sebelum shunt (V) |
Pada contoh baterai 9 V dan LED merah dengan resistor 220 Ω, arusnya sekitar (9 − 2) / 220 ≈ 32 mA; sekitar 3,2 mV jatuh di shunt dan daya total rangkaian adalah 9 V × 32 mA ≈ 290 mW. Ketika baterai mulai lemah, kamu bisa melihat secara langsung tegangannya turun ke 8 V dan arusnya ikut berkurang. Melihat nilai kecil seperti 0,1–0,5 mA tanpa beban terpasang itu normal; nilai itu berasal dari offset kecil di input chip dan bukan berarti pengukuranmu rusak.
Kalibrasi: kunci pengukuran yang akurat
Begitu INA219 dinyalakan, register kalibrasinya bernilai nol; jadi meskipun tegangan shunt dan tegangan jalur bisa langsung dibaca, register arus dan daya tetap nol. Nilai kalibrasi didapat dari dua rumus di datasheet: pertama hitung Current_LSB = arus maksimum yang diperkirakan / 32768 lalu bulatkan ke angka yang praktis, kemudian cari Cal = 0,04096 / (Current_LSB × R_shunt). Langkah register daya selalu 20 kali Current_LSB. Dengan shunt 0,1 Ω bawaan modul dan 3,2 A, Current_LSB = 3,2 / 32768 ≈ 97,7 µA, yang dibulatkan menjadi 100 µA; Cal = 0,04096 / (0,0001 × 0,1) = 4096 dan langkah dayanya 2 mW. Library Adafruit menyediakan tiga profil siap pakai yang melakukan hitungan ini untukmu:
| Fungsi | Rentang jalur | Rentang shunt | Arus maks. | Langkah arus |
|---|---|---|---|---|
| setCalibration_32V_2A() (bawaan) | 32 V | ±320 mV | ≈3,2 A | 0,1 mA |
| setCalibration_32V_1A() | 32 V | ±320 mV | ≈1,3 A | 0,04 mA |
| setCalibration_16V_400mA() | 16 V | ±40 mV | ≈400 mA | 0,05 mA |
“32 V” di tabel hanyalah rentang register; batas sebenarnya chip tetap 26 V. Kalau kamu sudah mengganti shunt, profil siap pakai akan memberi hasil yang salah. Solusi termudah adalah menghitung arus sendiri: arus (mA) = getShuntVoltage_mV() / R_shunt (Ω). Misalnya, kalau terbaca 15 mV dengan shunt 1 Ω, arusnya 15 mA. Untuk penyetelan halus terhadap acuan yang kamu percaya, pakai rumus koreksi dari datasheet: Cal_baru = Cal × (arus yang ditunjukkan multimeter / arus yang ditunjukkan INA219). Kalau multimeter menunjukkan 500 mA dan INA219 menunjukkan 495 mA, kamu menulis 4096 × 500 / 495 ≈ 4137. Karena register kalibrasi kembali nol ketika daya terputus, library Adafruit menulis ulang nilainya sebelum setiap pembacaan arus; kalau kamu menulis kodemu sendiri, kamu juga harus mengirim ulang kalibrasi setiap kali memulai sensor. Cara menulis langsung ke register akan kamu lihat di bagian Pico.
Konsumsi baterai dengan ESP32: penghitung mAh dan mWh
Untuk tahu berapa lama baterai akan bertahan, konsumsi total lebih penting daripada arus instan. Muatan total adalah akumulasi arus terhadap waktu: kalikan arus (mA) dengan waktu yang berlalu (jam) di setiap pengukuran lalu jumlahkan untuk mendapat mAh, dan lakukan hal yang sama dengan daya untuk mendapat mWh. Kode di bawah memakai pin I2C bawaan ESP32 (SDA 21, SCL 22), memilih profil 32V_1A agar langkahnya lebih halus, dan memperbarui totalnya setiap setengah detik. Karena tidak memakai fungsi yang bergantung pada versi, kode ini terkompilasi tanpa perubahan dengan ESP32 Arduino core 2.x maupun 3.x.
1#include <Wire.h>
2#include <Adafruit_INA219.h>
3
4Adafruit_INA219 ina219(0x40);
5
6float totalmAh = 0.0; // toplam yük / total charge
7float totalmWh = 0.0; // toplam enerji / total energy
8unsigned long lastMs = 0;
9
10void setup() {
11 Serial.begin(115200);
12 Wire.begin(21, 22); // SDA, SCL
13 if (!ina219.begin(&Wire)) {
14 Serial.println("INA219 bulunamadi / not found");
15 while (true) { delay(10); }
16 }
17 ina219.setCalibration_32V_1A(); // 1,3 A'e kadar, 0,04 mA adım / up to 1.3 A, 0.04 mA steps
18 lastMs = millis();
19}
20
21void loop() {
22 unsigned long now = millis();
23 if (now - lastMs >= 500) {
24 float hours = (now - lastMs) / 3600000.0; // geçen süre (saat) / elapsed time (hours)
25 lastMs = now;
26
27 float busV = ina219.getBusVoltage_V();
28 float currentmA = ina219.getCurrent_mA();
29 float powermW = ina219.getPower_mW();
30
31 totalmAh += currentmA * hours; // mA x saat = mAh / mA x hours = mAh
32 totalmWh += powermW * hours; // mW x saat = mWh / mW x hours = mWh
33
34 Serial.printf("%.2f V %.1f mA %.0f mW | %.3f mAh %.2f mWh\n",
35 busV, currentmA, powermW, totalmAh, totalmWh);
36 }
37}Misalnya, kalau sebuah node sensor menarik rata-rata 45 mA, sel 18650 2500 mAh secara teori bertahan 2500 / 45 ≈ 55 jam; dalam praktiknya, karena rugi-rugi konversi dan sel tidak dikosongkan sepenuhnya, lebih realistis memperhitungkan 70–80% dari angka itu. Hitungan ini bisa kamu lakukan dengan cepat lewat kalkulator umur baterai. Hati-hati dengan pengujian deep sleep: dengan shunt 0,1 Ω, langkah sebenarnya sekitar 0,1 mA, jadi arus sleep di tingkat mikroampere akan terlihat nol. Sebagian besar board pengembangan tetap menarik beberapa mA bahkan ketika sleep karena chip USB-serial dan regulatornya, dan INA219 bisa menunjukkannya dengan mudah. Untuk melihat arus sleep modul ESP32 polos yang sekitar 10 µA, kamu butuh shunt 1–10 Ω; arus maksimumnya lalu turun ke antara 320 mA dan 32 mA, jadi arus ketika aktif tidak bisa diukur dengan pengaturan yang sama.
Raspberry Pi Pico dan MicroPython: INA219 lewat register
Di MicroPython, mengendalikan INA219 langsung lewat register-nya tanpa library apa pun itu mudah sekaligus sangat mendidik. Nilai 0x399F yang kita tulis ke register konfigurasi (0x00) memilih rentang 32 V, PGA /8, resolusi 12-bit, dan mode pengukuran kontinu; ini juga nilai bawaan chip ketika dinyalakan. Lalu 4096 ditulis ke register kalibrasi (0x05). Tegangan shunt (0x01) dan arus (0x04) adalah bilangan 16-bit bertanda; untuk register tegangan jalur (0x02), 3 bit terbawah dibuang lalu nilainya dikalikan 4 mV. Kalau kodenya kamu simpan di Thonny sebagai main.py, Pico akan mulai mengukur setiap kali dinyalakan. Kalau kamu mengganti shunt, cukup perbarui R_SHUNT dan CURRENT_LSB; Cal dihitung otomatis. Kalau kamu baru mengenal MicroPython, artikel dasar-dasar MicroPython adalah titik awal yang bagus.
1from machine import Pin, I2C
2import time
3
4ADDR = 0x40 # A0, A1 boşta / A0, A1 open
5R_SHUNT = 0.1 # ohm, modüldeki R100 / the module's R100
6CURRENT_LSB = 0.0001 # 0,1 mA/bit
7CAL = round(0.04096 / (CURRENT_LSB * R_SHUNT)) # = 4096
8
9i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
10
11def write_reg(reg, value):
12 i2c.writeto_mem(ADDR, reg, bytes([(value >> 8) & 0xFF, value & 0xFF]))
13
14def read_reg(reg, signed=False):
15 d = i2c.readfrom_mem(ADDR, reg, 2)
16 v = (d[0] << 8) | d[1]
17 if signed and v > 32767: # ikiye tümleyen / two's complement
18 v -= 65536
19 return v
20
21print("Bulunan / found:", [hex(a) for a in i2c.scan()])
22write_reg(0x00, 0x399F) # 32 V, PGA /8, 12 bit, sürekli / 32 V, PGA /8, 12-bit, continuous
23write_reg(0x05, CAL) # kalibrasyon / calibration
24
25while True:
26 shunt_mv = read_reg(0x01, True) * 0.01 # 10 uV/bit
27 bus_v = (read_reg(0x02) >> 3) * 0.004 # 4 mV/bit
28 current_ma = read_reg(0x04, True) * CURRENT_LSB * 1000
29 power_mw = read_reg(0x03) * CURRENT_LSB * 20 * 1000 # güç adımı = 20 x LSB / power step = 20 x LSB
30 print("{:.2f} V {:.2f} mV {:.1f} mA {:.0f} mW".format(bus_v, shunt_mv, current_ma, power_mw))
31 time.sleep(1)Mengukur panel surya dan pengisian baterai
Di proyek panel surya, INA219 dipasang di antara positif panel dan rangkaian pengisi atau beban, lalu menunjukkan daya nyata yang dihasilkan panel pada momen itu. Ingat bahwa daya sesuai label hanya terlihat dengan beban yang cocok: tanpa beban arusnya nol dan tegangannya sama dengan tegangan rangkaian terbuka (Voc). Panel kecil 6 V 2 W memberi sekitar 330 mA di bawah matahari penuh; ketika mendung, nilai ini bisa turun sampai sepersepuluhnya. Dengan mencatat pengukuran sekali per menit, kamu bisa menghitung produksi energi harian dalam Wh, melihat pengaruh sudut panel, atau membandingkan panel tetap dengan pelacak matahari. Panel yang dijual sebagai “12 V” punya tegangan rangkaian terbuka sekitar 21–22 V; itu masih aman untuk INA219, tetapi kalau dua panel dipasang seri, batas 26 V akan terlampaui. Di sistem dengan panel dan baterai, kalau INA219 dipasang di antara baterai dan rangkaian dengan Vin+ ke arah baterai dan Vin− ke arah rangkaian, kamu memanfaatkan pengukuran dua arah: arus tampil positif ketika baterai memberi daya ke rangkaian dan negatif ketika baterai diisi. Dengan begitu kamu juga bisa melihat berapa arus yang benar-benar diberikan modul pengisi seperti TP4056 ke baterai.
INA219 atau ACS712?

| Fitur | INA219 | ACS712 (5 A) |
|---|---|---|
| Prinsip pengukuran | Resistor shunt + ADC | Efek Hall |
| Output | Digital (I2C) | Tegangan analog (VCC/2 pada arus nol) |
| Yang diukur | Arus, tegangan, dan daya | Hanya arus |
| Jenis arus | Hanya DC | AC dan DC |
| Rentang | ±3,2 A (dengan shunt 0,1 Ω), sampai 26 V | ±5 A (ada juga versi 20 A dan 30 A) |
| Resolusi | Sekitar 0,1 mA | 185 mV/A; sekitar 26 mA per langkah dengan ADC Uno |
| Isolasi | Tidak ada | Ada (2,1 kV RMS) |
| Catu daya | 3,0–5,5 V | 5 V |
Singkatnya, untuk rangkaian DC di bawah beberapa ampere, untuk pengukuran baterai dan panel surya, serta untuk proyek mikrokontroler berarus rendah, INA219 jauh lebih akurat dan praktis; INA219 juga tidak memakai pin analog dan sampai empat sensor bisa berbagi bus I2C yang sama. Memantau arus AC di sisi listrik PLN, melebihi 5 A, atau butuh isolasi listrik antara rangkaian yang diukur dan mikrokontroler adalah wilayah ACS712; lihat artikel sensor arus ACS712 untuk detailnya. Kalau kamu butuh tegangan di atas 26 V atau resolusi lebih tinggi, INA226 (36 V, 16-bit) dari keluarga yang sama adalah pilihan yang lebih baik, dan INA3221 menyatukan tiga kanal dalam satu chip. Kalau kamu ingin melihat tegangan yang diukur dalam rentang lebih lebar, metode pembagi tegangan di artikel voltmeter Arduino juga jadi pelengkap yang bagus.
Ide proyek dengan INA219
- Pengukur daya USB: Lewatkan jalur 5 V kabel USB melalui INA219 dan tampilkan berapa mA yang ditarik charger ponsel atau board Arduino di layar OLED.
- Pencatat energi surya: Ukur daya panel sekali per menit dengan ESP32, simpan ke modul kartu SD, dan hitung produksi Wh harian.
- Penguji kapasitas baterai: Kosongkan sel 18650 lewat beban resistor tetap sampai 3,0 V dan temukan kapasitas sebenarnya dari mAh yang terkumpul (lihat Apa Arti mAh?).
- Alarm motor macet: Hentikan motor DC ketika arusnya naik dua kali lipat; ideal untuk mendeteksi roda yang terjepit di mobil robot.
- Proteksi pompa berjalan kering: Ketika air habis, arus pompa mini turun cukup jelas; deteksi penurunan itu lalu matikan pompa untuk memperpanjang umurnya.
- Tampilan catu daya lab: Tampilkan tegangan, arus, dan daya output catu daya yang bisa diatur secara langsung di LCD I2C.
Kesalahan umum dan cara mengatasinya
| Gejala | Kemungkinan penyebab | Solusi |
|---|---|---|
| Pesan “INA219 not found” (INA219 tidak ditemukan) | SDA/SCL tertukar, VCC tidak tersambung, atau alamatnya berbeda | Cek kabel, cari alamat dengan scanner I2C (0x40–0x45) |
| Arus terbaca negatif | Vin+ dan Vin− tertukar | Hubungkan catu daya ke Vin+ dan beban ke Vin−, atau balik tandanya di software |
| Arus benar, tegangan 0 atau tidak masuk akal | Negatif beban dan GND INA219 tidak tersambung bersama | Satukan GND catu daya, beban, dan modul |
| Arus selalu 0 | Tidak ada beban, modul dipasang paralel, atau arus di bawah ukuran langkah | Cek sambungan seri; pakai shunt yang lebih besar untuk arus yang sangat kecil |
| Nilai tertahan di sekitar 3,2 A | Rentang tegangan shunt terlampaui | Kurangi beban atau pakai shunt yang lebih kecil dan hitung arusnya sendiri |
| Nilai terus melompat-lompat | Motor atau LED dikendalikan PWM, derau di kabel | Ambil rata-rata, naikkan jumlah sampel internal, terapkan filter software |
| Modul panas atau terbakar | Sambungan paralel (korsleting) atau arus di atas 3 A | Selalu pasang modul secara seri dan gunakan sekring di jalur |
Dengan satu modul kecil, INA219 memberi proyekmu voltmeter, amperemeter, dan wattmeter sekaligus; di balik banyak ide, dari panel surya dan umur baterai sampai proteksi motor dan pengukur daya USB, ada pengukuran yang akurat. Di aplikasi BlueGrays kamu akan menemukan proyek seperti voltmeter digital dengan layar LCD, deep sleep ESP32, pencatat suhu, dan penyiraman pintar, lengkap dengan skema rangkaian dan kode langkah demi langkah, lalu kamu bisa menambahkan INA219 ke proyek-proyek itu dan langsung mulai mengukur konsumsinya.
Pertanyaan umum
Berapa ampere maksimum yang bisa diukur INA219?
Dengan shunt 0,1 Ω di modul siap pakai, INA219 mengukur sampai sekitar ±3,2 A, karena batas tegangan shunt chip adalah ±320 mV. Kalau shunt diganti dengan resistor yang lebih kecil seperti 0,01 Ω, rentang teoretisnya naik menjadi 32 A; tetapi karena jalur tembaga dan terminal modul tidak dibuat untuk arus sebesar itu, kamu perlu memindahkan shunt dan kabel tebal ke luar board.
Apakah INA219 bisa mengukur arus AC?
Tidak. INA219 dirancang untuk rangkaian DC dan tegangan di terminalnya harus tetap di rentang 0–26 V; menghubungkannya ke listrik PLN akan merusak chip sekaligus membahayakan nyawa. Untuk arus AC dipakai sensor efek Hall berisolasi seperti ACS712 atau trafo arus seperti SCT-013.
Bagaimana cara mengganti alamat I2C INA219?
Jembatan solder A0 dan A1 di modul menentukan alamatnya: 0x40 jika keduanya terbuka, 0x41 jika hanya A0 tertutup, 0x44 jika hanya A1 tertutup, dan 0x45 jika keduanya tertutup. Di kode, cukup tentukan alamatnya seperti Adafruit_INA219 ina219(0x41);. Dengan begitu kamu bisa menghubungkan empat INA219 berbeda ke bus I2C yang sama.
Apa perbedaan INA219 dan INA226?
INA226 adalah anggota yang lebih canggih dari keluarga yang sama: tegangan jalurnya sampai 36 V dan ADC 16-bit-nya memberi resolusi yang jauh lebih tinggi. INA219 lebih murah dan lebih umum, dengan dukungan library Arduino yang sangat luas. Untuk proyek hobi di bawah 26 V dan beberapa ampere, INA219 sudah lebih dari cukup.
Apakah INA219 bisa bekerja di 3,3 V?
Bisa, rentang catu daya INA219 adalah 3,0–5,5 V. Di ESP32 dan Raspberry Pi Pico, memberi daya modul dari pin 3V3 membuat jalur I2C juga tetap di 3,3 V. Tegangan catu daya tidak membatasi jalur yang diukur; INA219 yang diberi daya 3,3 V tetap bisa mengukur jalur sampai 26 V.
Kenapa INA219 menunjukkan arus kecil meskipun tanpa beban?
Input shunt chip punya offset beberapa puluh mikrovolt; dengan shunt 0,1 Ω, ini berarti pembacaan kecil sekitar 0,1–0,5 mA. Galat ini bisa kamu hilangkan dengan mencatat nilai yang terbaca tanpa beban lalu menguranginya dari pengukuran berikutnya, atau dengan merata-ratakan beberapa pembacaan.
Proyek untuk dibuat setelah membaca ini
Lihat semua proyek
Voltmeter Digital dengan Layar LCD
Cari tahu berapa tegangan yang diberikan baterai atau adaptor daya dengan alat ukur buatanmu sendiri.

Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)
Mode Deep Sleep ESP32 menurunkan konsumsi arus hingga ~10 µA dengan mematikan CPU dan sebagian besar periferal, sehingga sangat penting untuk perangkat IoT bertenaga baterai. Di proyek ini, kita memakai tiga sumber bangun yang berbeda: timer (15 detik), pin eksternal (EXT0, tombol GPIO 33), dan sentuhan (T0/GPIO 4). Variabel yang ditandai RTC_DATA_ATTR dipertahankan selama deep sleep; penghitung boot, penghitung bangun karena timer, dan penghitung bangun karena tombol terus dilacak.

Pencatat Data Suhu ESP32 (DHT22 + RTC DS1307 + microSD + OLED)
Buat pencatat suhu bercap waktu dengan ESP32! Baca suhu/kelembapan DHT22 setiap menit, ambil waktu sebenarnya dari RTC DS1307, dan catat ke kartu microSD sebagai CSV. OLED menampilkan suhu langsung (font besar), kelembapan, cap waktu, dan penghitung catatan. File /temp_log.csv bisa dibuka di Excel, Google Sheets, atau Python pandas; cocok untuk rumah kaca, suhu kamar, data laboratorium, penyimpanan makanan, atau sarang lebah.

Menggunakan Layar LCD dengan I2C
Beri Arduino-mu layar sendiri dan buat ia menulis pesan pertamanya. Layar LCD dua baris tersambung hanya dengan beberapa kabel; sapaan muncul di baris atas, lalu pesan kedua di baris bawah, layar…

Layar LCD I2C ESP32 (16x2)
Di proyek ini, kita menampilkan teks dengan menyambungkan layar LCD karakter 16x2 ke ESP32 lewat protokol I2C. Berkat I2C, kita bisa mengendalikan layar hanya dengan dua pin data (SDA dan SCL), sehingga tidak perlu memboroskan 6+ pin seperti pada sambungan paralel klasik. Kode mencetak pesan tetap di baris pertama dan penghitung yang naik setiap detik di baris kedua. Selain itu, kita menjalankan pemindai I2C di awal untuk mencetak alamat layar ke Serial Monitor (biasanya 0x27).

Stasiun Penyiraman Pintar
Tukang kebun yang menyiram tanamanmu sendiri, supaya tanaman tidak kering ketika kamu berlibur.

Lampu Pintar ESP32 (PIR + LDR + Relay + OLED)
Ubah lorong, kamar mandi, atau gudangmu menjadi lampu pintar dengan ESP32! Dengan sensor gerak PIR, sensor cahaya LDR, dan modul relay, kita membuat skenario klasik "lampu menyala ketika ada gerakan dalam gelap"; jika sudah terang, gerakan TIDAK menyalakan lampu, jadi energi hemat di siang hari. Lampu menyala 30 detik; jika gerakan berlanjut, timer diulang. OLED SSD1306 menampilkan status dengan font besar (NYALA / SIANG / MENUNGGU) dan hitung mundur.
Artikel lainnya
Aplikasi BlueGrays
Rakit rangkaian ini langkah demi langkah di ponselmu
Skema pengkabelan, kode, dan daftar komponen dalam satu layar. 500+ proyek Arduino, ESP32, dan Pico siap dibuat.
Pindai dengan ponselmu
Arahkan kamera ke kode ini dan toko aplikasi di ponselmu akan terbuka.
atau buka toko aplikasi

