Voltmeter Arduino: Mengukur 0–25 V dengan LCD dan Kalibrasi

Voltmeter Arduino adalah alat ukur yang bisa kamu buat dalam satu malam: dua resistor, satu input analog, dan beberapa baris kode sudah cukup untuk mengukur 0–25 V secara akurat dan menampilkannya pada layar. Input analog Arduino hanya dapat membaca hingga 5 V, sehingga untuk mengukur tegangan yang lebih tinggi, kamu harus menurunkannya terlebih dahulu dengan pembagi tegangan, lalu mengalikannya kembali dengan rasio yang sama dalam kode. Pemantau baterai, tampilan catu daya, pencatat data panel surya, dan penguji baterai semuanya mengandalkan prinsip ini.

Dalam panduan ini kamu akan mempelajari langkah demi langkah cara memilih nilai resistor untuk rentang tertentu, cara zener dan resistor seri melindungi input analog dari tegangan berlebih, cara kerja modul sensor tegangan 0–25 V siap pakai, serta cara mengatur tegangan referensi dan melakukan kalibrasi agar hasil pembacaan mendekati multimeter. Lalu kamu akan menampilkan nilai pada LCD I2C, membuat voltmeter yang sama dengan ESP32 dan Raspberry Pi Pico, menambahkan pengukuran arus dengan INA219 untuk mengubahnya menjadi wattmeter, dan terakhir membuat penguji yang mengukur kapasitas nyata baterai dalam mAh.

Bagaimana cara kerja voltmeter Arduino?

Arduino tidak mengetahui tegangan secara langsung; ADC (konverter analog ke digital) membandingkan tegangan pada input analog dengan tegangan referensi lalu mengembalikan hasilnya sebagai bilangan bulat. ADC Arduino Uno memiliki resolusi 10-bit: terbaca 0 untuk 0 V dan 1023 untuk tegangan referensi (secara default 5 V). Tegangan pada pin adalah Vpin = pembacaan × Vref / 1024. Jika terdapat pembagi tegangan pada input, tegangan yang sebenarnya kamu ukur adalah Vin = Vpin × (R1 + R2) / R2. Jadi akurasi seluruh voltmeter bergantung pada tiga hal: nilai nyata Vref, rasio kedua resistor, dan galat ADC itu sendiri.

Pembagi tegangan dan pemilihan resistor untuk 0–25 V

Tegangan yang kamu ukur masuk melalui resistor atas R1, titik tengah pertemuan kedua resistor dihubungkan ke pin analog, dan resistor bawah R2 dihubungkan ke GND. Ketika memilih resistor, tentukan tegangan tertinggi terlebih dahulu, lalu pilih rasio yang membuat tegangan pin sedikit di bawah referensi pada tegangan tersebut, misalnya sekitar 4,5 V pada Uno. Pasangan 30 kΩ dan 7,5 kΩ yang digunakan dalam modul siap pakai membagi tepat sebesar 5: input 25 V menghasilkan 5,00 V pada pin. Jangan memilih nilai sembarangan: jika hambatan total terlalu rendah, pembagi membuang arus dari sumber yang kamu ukur, dan jika terlalu tinggi, kapasitor sampling dalam ADC tidak dapat terisi sehingga pembacaan bergeser. Datasheet ATmega328P menyarankan hambatan sumber yang menggerakkan input analog tidak melebihi 10 kΩ; untuk pembagi, hambatan sumber tersebut adalah R1 dan R2 secara paralel (6 kΩ untuk 30 kΩ dan 7,5 kΩ). Kamu bisa menemukan rincian rumus beserta efek pembebanan dalam artikel pembagi tegangan.

Proteksi: dioda zener, resistor seri, dan kapasitor

Meskipun pembagi sudah dihitung dengan benar, salah menempatkan probe, lonjakan pada catu daya, atau tidak sengaja menyentuh 48 V alih-alih 25 V dapat membuat tegangan pin melebihi 5 V. Pin ATmega328P hanya menoleransi hingga tegangan catu ditambah 0,5 V. Di dalam pin terdapat dioda proteksi ke 5 V dan GND, tetapi dioda ini hanya mampu menangani arus kecil. Untungnya, resistor atas pembagi sudah membatasi arus. Dengan R1 sebesar 30 kΩ, bahkan menyentuh 50 V hanya memungkinkan paling banyak sekitar 1,5 mA mengalir ke pin. Untuk mengurangi arus itu lebih jauh dan menyerap kelebihan tegangan dengan aman, kamu bisa menambahkan lapisan proteksi berikut.

• Resistor seri: Pasang resistor 4,7–10 kΩ di antara titik tengah pembagi dan pin analog. Ketika terjadi tegangan berlebih, arus menuju dioda internal pin turun ke rentang mikroampere.
• Kapasitor 100 nF: Hubungkan di antara pin analog dan GND. Kapasitor ini mengimbangi peningkatan hambatan sumber akibat resistor seri, karena ADC mengambil muatan yang dibutuhkan selama sampling dari kapasitor ini. Kapasitor juga menyaring derau dan lonjakan singkat.
• Dioda zener 5,1 V: Hubungkan zener seperti 1N4733A atau BZX55C5V1 dengan katode ke pin dan anode ke GND. Ketika tegangan berusaha naik di atas 5,1 V, zener menghantar dan membuang kelebihannya ke GND.
• Perhatikan arus bocor zener: Zener mulai menarik arus kecil sedikit di bawah tegangan breakdown-nya, dan pada pembagi berhambatan tinggi arus itu menurunkan hasil pembacaan. Jika menggunakan zener, jaga tegangan maksimum pin sekitar 4 V, atau gunakan dioda Schottky (BAT85) dari pin ke jalur 5 V sebagai gantinya.
• Polaritas terbalik: Jika probe dihubungkan terbalik, tegangan negatif mencapai pin. Resistor seri membatasi arus; untuk keamanan tambahan, kamu bisa memasang dioda Schottky kedua dengan anode ke GND dan katode ke pin.

Modul sensor tegangan siap pakai (0–25 V)

Jika kamu tidak ingin menyolder, gunakan modul kecil merah atau biru yang dijual sebagai “sensor tegangan”. Tidak ada yang ajaib di dalamnya: hanya pembagi yang terdiri dari resistor tepat 30 kΩ dan 7,5 kΩ, terminal sekrup, dan header tiga pin. Karena rasionya 5, kamu bisa mengukur 0–25 V dengan Arduino 5 V, tetapi hanya hingga 16,5 V dengan board 3,3 V. Pada board 3,3 V, menyentuh 25 V membuat pin menerima 5 V dan merusaknya, sehingga untuk ESP32 dan Pico lebih aman membuat pembagi sendiri sesuai tabel di atas. Modul tidak memiliki dioda proteksi, sehingga langkah proteksi zener atau Schottky dari bagian sebelumnya juga berlaku di sini.

Langkah demi langkah: voltmeter Arduino pertamamu

1. Hubungkan pin S modul ke A0 dan pin − ke GND. Jika membuat pembagi sendiri, pasang 30 kΩ di sisi sumber dan 7,5 kΩ di sisi GND, lalu hubungkan titik tengah ke A0.
2. Hubungkan Arduino ke USB, ukur antara pin 5V dan GND dengan multimeter, lalu catat nilainya. Tegangan USB sering berada di antara 4,7 dan 5,1 V.
3. Masukkan hasil pengukuranmu ke konstanta VREF dalam kode di bawah, lalu upload.
4. Hubungkan sumber yang ingin kamu ukur ke terminal sekrup modul: positif ke VCC, negatif ke GND. Baterai 9 V atau catu daya lab yang bisa diatur cocok untuk pengujian pertama.
5. Buka Serial Monitor pada 9600 baud. Baca tegangannya, dan pada waktu yang sama ukur sumber dengan multimetermu lalu bandingkan kedua nilai.

1// Arduino voltmetre: 0-25 V gerilim sensörü modülü / Arduino voltmeter: 0-25 V voltage sensor module
2// Modül S -> A0, modül - -> GND / module S -> A0, module - -> GND
3// Ölçülen kaynak modülün VCC ve GND klemensine / measured source goes to the module's VCC and GND terminals
4const int SENSE_PIN = A0;
5const float VREF = 5.00;       // 5V pininde ölçtüğün gerilim / voltage you measured on the 5V pin
6const float R1 = 30000.0;      // üst direnç (ohm) / top resistor (ohms)
7const float R2 = 7500.0;       // alt direnç (ohm) / bottom resistor (ohms)
8const float CAL = 1.000;       // kalibrasyon: gerçek / okunan / calibration: real / measured
9const int SAMPLES = 32;        // ortalama için örnek sayısı / samples to average
10
11float readVoltage() {
12  analogRead(SENSE_PIN);                    // ilk okumayı at / discard the first reading
13  unsigned long sum = 0;
14  for (int i = 0; i < SAMPLES; i++) {
15    sum += analogRead(SENSE_PIN);
16    delayMicroseconds(500);
17  }
18  float adc = (float)sum / SAMPLES;         // 0-1023 arası ortalama / average between 0 and 1023
19  float vPin = adc * VREF / 1024.0;         // pindeki gerilim / voltage at the pin
20  return vPin * (R1 + R2) / R2 * CAL;       // bölücüden önceki gerilim / voltage before the divider
21}
22
23void setup() {
24  Serial.begin(9600);
25}
26
27void loop() {
28  float v = readVoltage();
29  if (v < 0.05) v = 0.0;                    // boşta gürültüyü sıfırla / zero the noise when idle
30  Serial.print(F("Gerilim / Voltage: "));
31  Serial.print(v, 2);
32  Serial.println(F(" V"));
33  delay(500);
34}

Kode mengambil rata-rata dari 32 pembacaan setiap kali, sehingga sebagian besar fluktuasi ±1 langkah ADC hilang dan digit terakhir menjadi stabil. Pembacaan pertama dibuang karena kapasitor sampling ADC masih menyimpan muatan dari kanal sebelumnya. Membulatkan nilai di bawah 0,05 V menjadi nol mencegah nilai acak seperti 0,02–0,04 V muncul ketika tidak ada apa pun yang terhubung. Ingat bahwa resolusinya 24,4 mV: meskipun terlihat dua angka desimal, digit terakhir berubah dengan langkah 0,02–0,03 V. Jika memerlukan resolusi lebih halus, persempit rentangnya; dengan pembagi 0–10 V, satu langkah turun menjadi 10,7 mV.

Tegangan referensi dan kalibrasi

Orang sering mengatakan voltmeter Arduino “salah mengukur”, tetapi sumber galat sebenarnya biasanya adalah referensi. Jika kode berisi 5,00 V sementara board menerima 4,80 V dari USB, setiap pembacaan menjadi 4% terlalu tinggi: baterai 12,00 V terbaca sebagai 12,50 V. Tegangan ini berbeda antara komputer desktop dan laptop, serta antara kabel USB yang satu dan lainnya; ketika board diberi daya dari adaptor eksternal, regulatornya mengambil alih dan nilainya berubah lagi. Ada tiga cara mengatasinya: ukur pin 5V lalu masukkan nilainya ke kode, gunakan referensi internal tetap, atau hitung ulang tegangan catu board sendiri pada setiap pengukuran.

1// Kendi besleme gerilimini ölçen voltmetre (ATmega328P: Uno, Nano, Pro Mini)
2// Voltmeter that measures its own supply (ATmega328P: Uno, Nano, Pro Mini)
3const int SENSE_PIN = A0;
4const float R1 = 30000.0;      // üst direnç / top resistor
5const float R2 = 7500.0;       // alt direnç / bottom resistor
6long bandgapMv = 1100;         // iç referans (mV), kalibrasyonla düzelt / internal reference (mV), fix by calibration
7
8long readVccMv() {
9  // Referans AVcc, ölçülen kanal iç 1,1 V / reference AVcc, measured channel is the internal 1.1 V
10  ADMUX = _BV(REFS0) | _BV(MUX3) | _BV(MUX2) | _BV(MUX1);
11  delay(2);                                  // referans otursun / let the reference settle
12  ADCSRA |= _BV(ADSC);                       // dönüşümü başlat / start a conversion
13  while (bit_is_set(ADCSRA, ADSC)) {}        // bitmesini bekle / wait until it finishes
14  unsigned int raw = ADCW;                   // 10 bit sonuç / 10-bit result
15  return bandgapMv * 1024L / raw;            // Vcc = 1,1 V x 1024 / okunan / Vcc = 1.1 V x 1024 / reading
16}
17
18float readVoltage(float vcc) {
19  analogRead(SENSE_PIN);                     // kanal değişti, ilk okumayı at / channel changed, discard first
20  unsigned long sum = 0;
21  for (int i = 0; i < 32; i++) sum += analogRead(SENSE_PIN);
22  float vPin = (sum / 32.0) * vcc / 1024.0;
23  return vPin * (R1 + R2) / R2;
24}
25
26void setup() {
27  Serial.begin(9600);
28}
29
30void loop() {
31  float vcc = readVccMv() / 1000.0;
32  float v = readVoltage(vcc);
33  Serial.print(F("Vcc: "));
34  Serial.print(vcc, 3);
35  Serial.print(F(" V   Giris / Input: "));
36  Serial.print(v, 2);
37  Serial.println(F(" V"));
38  delay(500);
39}

1. Kalibrasi referensi internal: Jalankan kode readVcc lalu bandingkan nilai Vcc di Serial Monitor dengan hasil pembacaan multimeter pada pin 5V. bandgapMv baru = 1100 × hasil pengukuran / nilai yang ditampilkan. Misalnya, jika board menampilkan 5,12 V dan multimeter membaca 4,98 V, masukkan 1100 × 4.98 / 5.12 ≈ 1070.
2. Kalibrasi satu titik: Hubungkan tegangan yang diketahui mendekati batas atas rentang (misalnya 12 V). CAL = nilai multimeter / nilai Arduino. Faktor ini juga mengoreksi galat rasio akibat toleransi resistor.
3. Kalibrasi dua titik: Jika terlihat offset tetap pada tegangan rendah, ukur di dua titik, satu rendah (misalnya 2 V) dan satu tinggi (misalnya 20 V). Kemiringan = (M2 − M1) / (A2 − A1), offset = M1 − kemiringan × A1; hasilnya adalah nilai sebenarnya = kemiringan × pembacaan + offset (M adalah nilai multimeter, A adalah nilai Arduino).
4. Verifikasi: Setelah kalibrasi, periksa hasilnya dengan tegangan ketiga di tengah rentang. Voltmeter Uno yang dibuat dengan cermat dapat mengukur 0–25 V dengan galat di bawah 1%.

Voltmeter digital dengan LCD

Agar voltmeter tidak bergantung pada komputer, cukup tampilkan nilainya pada LCD I2C. Hubungkan GND LCD ke GND, VCC ke 5V, SDA ke A4, dan SCL ke A5. Instal library LiquidCrystal I2C (Frank de Brabander) dari Library Manager. Alamat layar biasanya 0x27, atau 0x3F pada beberapa modul. Kode di bawah menampilkan tegangan terkini pada baris atas serta nilai terendah dan tertinggi sejak dinyalakan pada baris bawah, sehingga kamu juga bisa menangkap penurunan tegangan baterai ketika motor bekerja.

1// LCD ekranlı dijital voltmetre (0-25 V, min/maks) / Digital voltmeter with LCD (0-25 V, min/max)
2// LCD: SDA -> A4, SCL -> A5, VCC -> 5V, GND -> GND; sensör S -> A0 / sensor S -> A0
3#include <Wire.h>
4#include <LiquidCrystal_I2C.h>
5
6LiquidCrystal_I2C lcd(0x27, 16, 2);   // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8const int SENSE_PIN = A0;
9const float VREF = 5.00;              // 5V pininde ölçülen / measured on the 5V pin
10const float RATIO = (30000.0 + 7500.0) / 7500.0;   // = 5,0
11const float CAL = 1.000;              // kalibrasyon katsayısı / calibration factor
12
13float vMin = 99.99;
14float vMax = 0.0;
15
16float readVoltage() {
17  analogRead(SENSE_PIN);
18  unsigned long sum = 0;
19  for (int i = 0; i < 32; i++) sum += analogRead(SENSE_PIN);
20  float v = (sum / 32.0) * VREF / 1024.0 * RATIO * CAL;
21  return v < 0.05 ? 0.0 : v;
22}
23
24void printField(float value) {
25  char buf[8];
26  dtostrf(value, 5, 2, buf);          // sabit genişlik: " 9.87" / fixed width: " 9.87"
27  lcd.print(buf);
28}
29
30void setup() {
31  lcd.init();
32  lcd.backlight();
33  lcd.print(F("Voltmetre 0-25V"));
34  delay(1000);
35  lcd.clear();
36}
37
38void loop() {
39  float v = readVoltage();
40  if (v > 0.5) {                      // boştayken min/maks güncelleme / don't update min/max when idle
41    if (v < vMin) vMin = v;
42    if (v > vMax) vMax = v;
43  }
44
45  lcd.setCursor(0, 0);
46  lcd.print(F("V: "));
47  printField(v);
48  lcd.print(F(" V      "));
49
50  lcd.setCursor(0, 1);
51  lcd.print(F("L"));
52  printField(vMin > 99.0 ? 0.0 : vMin);
53  lcd.print(F("  H"));
54  printField(vMax);
55  lcd.print(F("  "));
56  delay(300);
57}

Membuat voltmeter dengan ESP32

ESP32 bekerja pada 3,3 V dan pinnya tidak dapat menerima lebih dari 3,6 V, jadi gunakan pembagi 100 kΩ + 10 kΩ untuk 0–25 V: input 25 V menghasilkan 2,27 V pada pin. Hubungkan pembagi ke salah satu pin ADC1 (GPIO 32–39); pin ADC2 tidak bekerja ketika Wi-Fi aktif. ADC ESP32 memiliki resolusi 12-bit tetapi tidak linear di kedua ujung rentangnya: hampir tidak mendeteksi apa pun di bawah 0,15 V, dan galatnya meningkat di atas 2,5 V. Fungsi analogReadMilliVolts() menggunakan data kalibrasi yang ditulis ke chip di pabrik dan menghasilkan nilai milivolt yang jauh lebih akurat daripada nilai mentah. Untuk menghilangkan offset yang tersisa, kode menerapkan kalibrasi dua titik dari bagian sebelumnya dengan konstanta GAIN dan OFFSET.

1// ESP32 voltmetre: 100k + 10k bölücü ile 0-25 V / ESP32 voltmeter: 0-25 V with a 100k + 10k divider
2// Kaynak + -> 100k -> GPIO 34 -> 10k -> GND, kaynak - -> GND / source + -> 100k -> GPIO 34 -> 10k -> GND
3const int SENSE_PIN = 34;                 // ADC1_CH6, Wi-Fi açıkken de çalışır / works with Wi-Fi on
4const float RATIO = (100000.0 + 10000.0) / 10000.0;   // = 11,0
5const float GAIN = 1.000;                 // iki noktalı kalibrasyon: eğim / two-point calibration: slope
6const float OFFSET = 0.00;                // iki noktalı kalibrasyon: kayma (V) / two-point calibration: offset (V)
7
8float readVoltage() {
9  uint32_t mv = 0;
10  for (int i = 0; i < 64; i++) {
11    mv += analogReadMilliVolts(SENSE_PIN);   // fabrika kalibrasyonlu mV / factory-calibrated mV
12  }
13  float vPin = mv / 64.0 / 1000.0;           // pindeki gerilim (V) / voltage at the pin (V)
14  float v = vPin * RATIO * GAIN + OFFSET;
15  return v < 0.10 ? 0.0 : v;
16}
17
18void setup() {
19  Serial.begin(115200);
20  analogReadResolution(12);                  // 0-4095
21}
22
23void loop() {
24  float v = readVoltage();
25  Serial.printf("Gerilim / Voltage: %.2f V\n", v);
26  delay(500);
27}

Membuat voltmeter dengan Raspberry Pi Pico (MicroPython)

Pada Raspberry Pi Pico, input analognya adalah GP26, GP27, dan GP28. Hubungkan pembagi 100 kΩ + 10 kΩ yang sama seperti pada ESP32 ke GP26. Dalam MicroPython, read_u16() mengembalikan hasil 12-bit yang diskalakan ke 0–65535. Referensi ADC Pico diperoleh dengan menyaring jalur 3,3 V; untuk akurasi lebih baik, ukur antara ADC_VREF (pin 35) dan GND dengan multimeter lalu masukkan nilainya ke VREF. Ada bonus dalam kodenya: pada Pico standar, GP29 (ADC3) terhubung ke pembagi internal yang membagi input catu VSYS board sebesar 3. Jadi tanpa komponen tambahan, kamu juga bisa membaca tegangan baterai yang memberi daya ke Pico. Pada Pico W dan Pico 2 W, GP29 berbagi fungsi dengan chip nirkabel, sehingga baris ini tidak bisa langsung digunakan pada board tersebut.

1# Raspberry Pi Pico voltmetre (MicroPython) / Raspberry Pi Pico voltmeter (MicroPython)
2# Kaynak + -> 100k -> GP26 -> 10k -> GND / source + -> 100k -> GP26 -> 10k -> GND
3from machine import ADC
4import time
5
6sense = ADC(26)            # GP26 = ADC0 (pin 31)
7vsys = ADC(29)             # GP29 = VSYS / 3 (yalnız standart Pico / standard Pico only)
8VREF = 3.3                 # ADC_VREF; multimetreyle ölçüp düzelt / measure and correct with a multimeter
9RATIO = (100000 + 10000) / 10000    # = 11.0
10GAIN = 1.000               # iki noktalı kalibrasyon: eğim / two-point calibration: slope
11OFFSET = 0.00              # iki noktalı kalibrasyon: kayma (V) / two-point calibration: offset (V)
12
13
14def pin_voltage(adc, samples=64):
15    total = 0
16    for _ in range(samples):
17        total += adc.read_u16()            # 0-65535
18    return total / samples * VREF / 65535  # pindeki gerilim / voltage at the pin
19
20
21while True:
22    v_in = pin_voltage(sense) * RATIO * GAIN + OFFSET
23    if v_in < 0.05:
24        v_in = 0.0
25    v_sys = pin_voltage(vsys) * 3          # VSYS = GP29 x 3
26    print("Giris / Input: {:.2f} V   VSYS: {:.2f} V".format(v_in, v_sys))
27    time.sleep(0.5)

Menambahkan pengukuran arus untuk membuat wattmeter: ACS712 atau INA219

Ketika menambahkan pengukuran arus ke voltmeter, kamu juga mendapatkan daya: P = V × I. Jika baterai 12 V memasok 1,5 A, dayanya adalah 18 W. Akumulasikan daya terhadap waktu dan kamu mendapatkan energi: beban 18 W yang bekerja selama 2 jam menggunakan 36 Wh. Ada dua pilihan umum. ACS712 memiliki output analog, juga mengukur arus AC, dan menyediakan isolasi; cukup jadikan kanal analog kedua pada voltmetermu. INA219 adalah pemantau daya DC yang mengukur tegangan dan arus dalam chip yang sama dengan presisi 12-bit serta berkomunikasi melalui I2C; modul ini sendiri sudah menjadi wattmeter siap pakai.

1// INA219 + I2C LCD ile wattmetre: V, A, W ve Wh / Wattmeter with INA219 + I2C LCD: V, A, W and Wh
2// Kaynak + -> INA219 VIN+ ; INA219 VIN- -> yük + ; yük - -> kaynak - -> Arduino GND
3// Source + -> INA219 VIN+ ; INA219 VIN- -> load + ; load - -> source - -> Arduino GND
4#include <Wire.h>
5#include <Adafruit_INA219.h>
6#include <LiquidCrystal_I2C.h>
7
8Adafruit_INA219 ina219;               // varsayılan adres 0x40 / default address 0x40
9LiquidCrystal_I2C lcd(0x27, 16, 2);
10
11float energyWh = 0.0;
12unsigned long lastMs = 0;
13
14void printField(float value, int width, int decimals) {
15  char buf[10];
16  dtostrf(value, width, decimals, buf);
17  lcd.print(buf);
18}
19
20void setup() {
21  Serial.begin(9600);
22  lcd.init();
23  lcd.backlight();
24  if (!ina219.begin()) {              // modül bulunamadı / module not found
25    lcd.print(F("INA219 yok!"));
26    while (true) delay(10);
27  }
28  // ina219.setCalibration_16V_400mA();  // küçük akımlar için daha hassas / finer for small currents
29  lastMs = millis();
30}
31
32void loop() {
33  float busV = ina219.getBusVoltage_V();           // VIN- ile GND arası / between VIN- and GND
34  float shuntMv = ina219.getShuntVoltage_mV();     // şönt üzerindeki düşüm / drop across the shunt
35  float loadV = busV + shuntMv / 1000.0;           // kaynağın gerilimi / source voltage
36  float currentA = ina219.getCurrent_mA() / 1000.0;
37  float powerW = loadV * currentA;
38
39  unsigned long now = millis();
40  energyWh += powerW * (now - lastMs) / 3600000.0; // W x saat = Wh / W x hours = Wh
41  lastMs = now;
42
43  lcd.setCursor(0, 0);
44  printField(loadV, 5, 2);  lcd.print(F("V "));
45  printField(currentA, 6, 3); lcd.print(F("A  "));
46  lcd.setCursor(0, 1);
47  printField(powerW, 6, 2); lcd.print(F("W "));
48  printField(energyWh, 6, 2); lcd.print(F("Wh"));
49
50  Serial.print(loadV, 2);    Serial.print(F(" V, "));
51  Serial.print(currentA, 3); Serial.print(F(" A, "));
52  Serial.print(powerW, 2);   Serial.print(F(" W, "));
53  Serial.print(energyWh, 3); Serial.println(F(" Wh"));
54  delay(500);
55}

INA219 menghitung arus dari jatuh tegangan kecil pada resistor shunt 0,1 Ω di antara VIN+ dan VIN−, sehingga modul dipasang secara seri pada sisi positif sumber (high side). Karena tegangan bus diukur antara VIN− dan GND, kode menambahkan jatuh tegangan shunt untuk memperoleh tegangan sumber yang sebenarnya. Kalibrasi default adalah untuk 32 V dan 2 A; jika hanya akan mengukur beberapa ratus miliampere, aktifkan baris setCalibration_16V_400mA() untuk mempersempit rentang menjadi 400 mA dan meningkatkan akurasi pada arus kecil. Energi diperoleh dengan menjumlahkan daya terkini yang dikalikan waktu berlalu pada setiap perulangan; nilainya di-reset ketika Arduino dimatikan, jadi untuk menyimpannya, tulis nilai ke EEPROM secara berkala. Untuk kode yang melakukan perhitungan yang sama dengan ACS712, lihat bagian daya dan energi dalam artikel ACS712.

Penguji baterai: voltmeter yang mengukur kapasitas (mAh)

Tegangan baterai tidak menunjukkan secara tepat berapa banyak energi yang tersisa di dalamnya; sel yang penuh tetapi sudah aus juga bisa menunjukkan 4,1 V. Cara mengetahui kapasitas sebenarnya adalah mengosongkan baterai melalui beban yang diketahui lalu mengakumulasikan arus terhadap waktu: mAh = Σ (arus × waktu). Dalam rangkaian ini, MOSFET mengaktifkan dan menonaktifkan beban, sedangkan Arduino mengukur tegangan baterai dan tegangan pada ujung bawah resistor beban sekali setiap detik. Selisih kedua tegangan dibagi hambatan beban menghasilkan arus. Ketika baterai mencapai tegangan pemutusan, MOSFET dimatikan dan hasilnya ditampilkan. Pada awal pengujian, kode juga membandingkan tegangan baterai tanpa beban dan dengan beban untuk menghitung hambatan dalam; semakin tinggi hambatan dalam, semakin besar penurunan tegangan baterai pada arus tinggi.

1// Pil kapasite test cihazı: mAh, Wh ve iç direnç / Battery capacity tester: mAh, Wh and internal resistance
2// Pil + -> 10k -> A0 ; pil + -> 4,7 ohm yük -> MOSFET drain ; drain -> 10k -> A1
3// Battery + -> 10k -> A0 ; battery + -> 4.7 ohm load -> MOSFET drain ; drain -> 10k -> A1
4// MOSFET source -> GND ; gate <- D9 (220 ohm), gate -> 100k -> GND ; pil - / battery - -> GND
5const int BAT_PIN = A0;
6const int DRAIN_PIN = A1;
7const int LOAD_PIN = 9;
8const float VREF = 5.00;        // 5V pininde ölçülen / measured on the 5V pin
9const float R_LOAD = 4.7;       // yük direnci, multimetreyle ölç / load resistor, measure it
10const float CUTOFF_V = 3.00;    // Li-ion 3,00 V ; alkalin AA / alkaline AA 0,90 V
11
12float mAh = 0.0;
13float wh = 0.0;
14unsigned long lastMs = 0;
15unsigned long startMs = 0;
16bool running = false;
17
18float readPin(int pin) {
19  analogRead(pin);                          // kanal değişti, ilk okumayı at / discard first reading
20  unsigned long sum = 0;
21  for (int i = 0; i < 32; i++) sum += analogRead(pin);
22  return (sum / 32.0) * VREF / 1024.0;
23}
24
25float loadCurrent(float vBat) {
26  return (vBat - readPin(DRAIN_PIN)) / R_LOAD;   // dirençteki gerilim / R / voltage across R / R
27}
28
29void setup() {
30  Serial.begin(9600);
31  pinMode(LOAD_PIN, OUTPUT);
32  digitalWrite(LOAD_PIN, LOW);              // yük kapalı / load off
33  delay(1000);
34
35  float vOpen = readPin(BAT_PIN);           // yüksüz gerilim / open-circuit voltage
36  if (vOpen < CUTOFF_V + 0.1) {
37    Serial.println(F("Pil zayif ya da takili degil / Battery low or missing"));
38    return;
39  }
40  digitalWrite(LOAD_PIN, HIGH);             // yükü aç / load on
41  delay(1000);
42  float vLoad = readPin(BAT_PIN);
43  float amps = loadCurrent(vLoad);
44  Serial.print(F("Bos / Open: "));
45  Serial.print(vOpen, 3);
46  Serial.print(F(" V  Yuklu / Loaded: "));
47  Serial.print(vLoad, 3);
48  Serial.print(F(" V  Ic direnc / Internal R: "));
49  Serial.print((vOpen - vLoad) / amps * 1000.0, 0);
50  Serial.println(F(" mOhm"));
51
52  running = true;
53  startMs = lastMs = millis();
54}
55
56void loop() {
57  if (!running) return;
58  unsigned long now = millis();
59  if (now - lastMs < 1000) return;          // saniyede bir ölç / measure once per second
60
61  float hours = (now - lastMs) / 3600000.0;
62  lastMs = now;
63  float vBat = readPin(BAT_PIN);
64  float amps = loadCurrent(vBat);
65  mAh += amps * 1000.0 * hours;             // akım x süre / current x time
66  wh += vBat * amps * hours;
67
68  Serial.print((now - startMs) / 1000);
69  Serial.print(F(" s  "));
70  Serial.print(vBat, 3);
71  Serial.print(F(" V  "));
72  Serial.print(amps, 3);
73  Serial.print(F(" A  "));
74  Serial.print(mAh, 0);
75  Serial.println(F(" mAh"));
76
77  if (vBat <= CUTOFF_V) {                   // kesme gerilimi / cut-off voltage
78    digitalWrite(LOAD_PIN, LOW);
79    running = false;
80    Serial.print(F("Bitti / Done: "));
81    Serial.print(mAh, 0);
82    Serial.print(F(" mAh, "));
83    Serial.print(wh, 2);
84    Serial.println(F(" Wh"));
85  }
86}

Dengan beban 4,7 Ω, sel 18650 dikosongkan dengan arus yang dimulai sekitar 0,9 A dan turun menuju 0,65 A; menguji sel 2500 mAh yang sehat memerlukan sekitar tiga jam. Untuk Li-ion, jangan pernah mengatur tegangan pemutusan di bawah 3,0 V, atau sel akan rusak. Jika kamu menguji baterai AA alkalin, atur CUTOFF_V ke 0,9 V; dengan beban yang sama arusnya sekitar 0,3 A. Kamu bisa membandingkan hasil dengan label dan kalkulator umur baterai. Hambatan dalam 18650 baru yang diukur dengan cara ini, termasuk tempat baterai dan kabel, biasanya di bawah 0,15 Ω; sel di atas 0,3 Ω tidak boleh digunakan untuk pekerjaan berarus tinggi. Untuk memahami satuan kapasitas, baca artikel mAh dan kapasitas baterai.

Ide proyek dengan voltmeter Arduino

• Pemantau baterai dan alarm tegangan rendah: Pantau aki 12 V pada mobil kemping atau sistem surya lalu bunyikan buzzer ketika tegangannya turun di bawah 11,8 V.
• Pencatat data panel surya: Tulis tegangan panel dan arusnya melalui INA219 ke kartu SD setiap menit lalu hitung hasil energi harian dalam Wh.
• Tampilan catu daya lab: Tambahkan voltmeter dan INA219 ke output modul LM2596 untuk mengubahnya menjadi catu daya lab.
• Pemantauan baterai jarak jauh: Kirim tegangan yang kamu ukur dengan ESP32 ke Home Assistant melalui MQTT, atau terima pesan Telegram ketika tegangannya rendah.
• Pemeriksaan paket baterai 18650: Uji kapasitas sel yang kamu isi dengan TP4056, lalu cocokkan sel berkapasitas serupa untuk membuat paket yang seimbang.
• Tampilan angka besar: Tampilkan nilai pada display 7-segmen atau layar OLED sebagai pengganti LCD, dengan ukuran cukup besar untuk dibaca dari seberang ruangan.

Kesalahan umum dan cara mengatasinya

Voltmeter Arduino adalah salah satu cara terbaik untuk mempelajari cara kerja pengukuran: dengan dua resistor, satu rumus, dan sedikit kalibrasi, kamu mendapatkan hasil yang mendekati multimeter; tambahkan sensor arus dan alat ini menjadi wattmeter, tambahkan MOSFET dan alat ini menjadi penguji baterai. Dalam aplikasi BlueGrays, proyek “Voltmeter Digital dengan Layar LCD” memungkinkan kamu membuat rangkaian yang sama langkah demi langkah dengan skema pengkabelan dan kode siap pakai, lalu melanjutkan ke proyek pemantauan baterai dan pengukuran daya.