Apa Arti mAh? Penjelasan Kapasitas Baterai, Wh, dan Waktu Pakai

Apa arti mAh? Singkatnya, mAh (miliampere-jam) adalah satuan kapasitas yang menunjukkan berapa banyak muatan listrik yang disimpan sebuah baterai. 1 mAh berarti arus 1 miliampere yang mengalir selama 1 jam, jadi baterai berkapasitas 2000 mAh secara teori bisa memberi daya rangkaian yang menarik 20 mA selama 100 jam, atau rangkaian yang menarik 200 mA selama 10 jam. Tapi angka itu saja belum cukup: tegangan baterai, arus yang kamu tarik, suhu, dan regulator di antara baterai dan rangkaianmu semuanya bisa mengubah waktu pakai sebenarnya secara drastis.

Ketika kamu membuat proyek bertenaga baterai dengan Arduino, ESP32, atau Raspberry Pi Pico, pertanyaan pertamanya selalu sama: baterai ini akan bertahan berapa jam atau berapa hari? Di panduan ini kamu akan belajar arti mAh dan Wh, kapasitas nyata baterai AA, 9V, 18650, dan LiPo, cara mengukur arus yang ditarik proyekmu dengan multimeter dan INA219, cara menghitung waktu pakai dengan rumus, cara menghubungkan baterai secara seri dan paralel, apa itu rating C, dan kenapa baterai 9V adalah pilihan yang buruk, semuanya dengan angka nyata.

Apa arti mAh? Penjelasan kapasitas baterai

Arus diukur dalam ampere (A), dan kapasitas dalam ampere-jam (Ah). Untuk baterai kecil kita memakai miliampere-jam, yaitu seperseribunya: 1 Ah = 1000 mAh. Dalam istilah fisika, ini adalah muatan listrik; 1 mAh sama dengan 3,6 coulomb. Produsen mengukur kapasitas pada arus pengosongan tertentu sampai tegangan cut-off tertentu. Makin besar arusnya, makin banyak tegangan yang hilang di hambatan dalam baterai, reaksi kimianya tidak bisa mengejar, dan tegangan cut-off tercapai lebih cepat, sehingga baterai yang sama memberikan mAh lebih sedikit pada arus tinggi. Cuaca dingin juga menurunkan kapasitas; baterai alkaline melemah dengan jelas di bawah 0 °C. Tabel di bawah menunjukkan bagaimana arus yang kamu tarik mengubah kapasitas baterai alkaline AA, berdasarkan data Energizer (sampai 0,8 V, pada 21 °C).

Bedanya mencolok: ketika arus dinaikkan 20 kali lipat, waktu pakai tidak turun 20 kali lipat, tetapi 40 kali lipat. Jadi anggap angka mAh di label sebagai kondisi terbaik. Di proyek nyata ada satu kerugian lagi: rangkaian berhenti sebelum baterai benar-benar habis. Regulator Arduino Uno tidak bisa lagi mempertahankan 5 V begitu inputnya turun di bawah 7 V, dan satu sel lithium sebaiknya diputus di sekitar 3,0–3,3 V supaya umurnya tidak berkurang. Energi yang masih tersisa di baterai pada titik itu tidak pernah terpakai.

Apa arti Wh? mAh vs Wh

mAh hanya memberi tahu jumlah muatan; untuk mengetahui energi baterai, kamu harus mengalikannya dengan tegangan. Satuan energi adalah watt-jam (Wh), dan rumusnya: Wh = mAh × V / 1000. Misalnya, sel 18650 3,7 V 3000 mAh menyimpan 3,7 × 3 = 11,1 Wh. Baterai AA 2500 mAh di atas kertas menghasilkan 1,5 × 2,5 = 3,75 Wh, tetapi karena tegangan rata-rata sel alkaline turun ke 1,2–1,3 V selama pengosongan, angka sebenarnya sekitar 3 Wh. Itulah sebabnya membandingkan baterai dengan tegangan berbeda hanya dari mAh-nya itu menyesatkan: baterai 9V 550 mAh terlihat jauh lebih kecil daripada AA 2500 mAh, padahal dengan sekitar 4 Wh energinya sedikit lebih banyak. Mana yang lebih awet di proyekmu bergantung pada jenis regulator di antaranya; kamu akan melihatnya di bagian waktu pakai. Untuk cepat menghitung hubungan antara daya dan arus (P = V × I), kamu bisa memakai kalkulator hukum Ohm.

Tabel perbandingan baterai AA, 9V, 18650, dan LiPo

Ketika membaca tabel, ingat: sel lithium seperti 18650 dan LiPo menyimpan energi paling banyak untuk bobotnya; satu 18650 menyimpan energi yang hampir sama dengan total empat baterai alkaline AA, dengan bobot sekitar separuhnya. Baterai alkaline bagus untuk perangkat berarus rendah yang lama disimpan di rak, karena kapasitasnya hanya berkurang beberapa persen per tahun; tetapi di bawah beban berarus tinggi seperti motor atau servo, tegangannya cepat anjlok. Sel isi ulang NiMH mudah memberikan arus tinggi meskipun tegangannya hanya 1,2 V, dan jenis self-discharge rendah (LSD) tetap terisi selama berbulan-bulan. Baterai koin CR2032 hanya untuk modul jam dan sensor yang tidur di level mikroampere; baterai ini sama sekali tidak bisa memberi daya ESP32 yang sedang terhubung ke Wi-Fi.

Kenapa baterai 9V pilihan yang buruk?

Baterai 9V berbentuk kotak sering ada di starter kit karena konektor jepretnya langsung masuk ke jack DC Arduino, tetapi baterai ini termasuk pilihan terburuk untuk proyek Arduino bertenaga baterai. Di dalamnya ada enam sel kecil yang disusun seri, jadi kapasitasnya hanya 400–600 mAh. Menurut data Energizer, baterai alkaline 9V yang dikosongkan sampai 4,8 V memberikan sekitar 600 mAh pada 10 mA, 570 mAh pada 25 mA, dan hanya 450 mAh pada 50 mA. Di sisi lain, regulator Arduino Uno butuh minimal 7 V di jack DC; di bawah beban, tegangan baterai turun di bawah angka itu dalam beberapa jam dan sisa energinya tidak bisa dipakai. Itulah sebabnya Uno yang menarik sekitar 50 mA biasanya hanya berjalan beberapa jam dengan baterai 9V, sering kali 4–8 jam.

• Kapasitas rendah: hanya 400–600 mAh dibandingkan 2000–2500 mAh untuk pack 6×AA, artinya waktu pakai lebih dari empat kali lebih singkat pada tegangan 9 V yang sama.
• Hambatan dalam tinggi: ketika servo mulai bergerak atau relay berpindah, tegangannya langsung anjlok dan Arduino reset.
• Kerugian di regulator: regulator linear Uno mengubah selisih 4 V antara 9 V dan 5 V menjadi panas; pada 50 mA, sekitar 0,2 W dari 0,45 W yang ditarik dari baterai terbuang.
• Energi yang mahal: biaya per Wh-nya jelas lebih tinggi daripada baterai AA, dan baterai 9V NiMH isi ulang hanya punya 170–300 mAh.
• Di mana baterai ini cocok: baterai 9V sangat pas untuk detektor asap, multimeter, atau perangkat yang menarik beberapa mA dan lama menganggur. Untuk Arduino, pilih pack 6×AA, pack 18650 2S, atau power bank; detailnya ada di Cara memberi daya ke Arduino dengan baterai.

Mengukur arus yang ditarik proyek Arduino-mu

Untuk menghitung umur baterai, kamu harus tahu dulu berapa arus yang ditarik proyekmu. Mengukur lebih baik daripada menebak, karena konsumsi board itu sendiri, LED power, dan regulator sering menarik arus lebih besar daripada sensornya. Cara paling mudah adalah memasang multimeter secara seri di antara baterai dan rangkaian. Untuk proyek dengan siklus sleep/bangun, sensor arus seperti INA219 memberi hasil lebih baik, karena bisa menangkap puncak arus yang singkat dan rata-rata sebenarnya. Untuk detail rentang dan soket multimeter, lihat Cara Memakai Multimeter.

1. Matikan rangkaian; colokkan probe merah ke soket mA multimeter dan probe hitam ke COM. Kalau menurutmu arusnya bisa melebihi 200 mA, mulai dari soket 10A.
2. Putar sakelar ke arus DC (A⎓), dan ke rentang 200 mA kalau multimeternya bukan auto-range.
3. Lepaskan kabel positif baterai dari rangkaian; tempelkan probe merah ke kutub positif baterai dan probe hitam ke input positif rangkaian. Dengan cara ini seluruh arus mengalir lewat multimeter.
4. Jalankan rangkaian dan baca nilainya. Ukur terpisah ketika servo bergerak, ketika Wi-Fi sedang menyambung, atau ketika relay aktif, lalu catat arus untuk setiap kondisi.
5. Kalau arus sleep-nya di kisaran mikroampere, pindah ke rentang µA. Di rentang ini board mungkin tidak mendapat arus yang cukup untuk boot; jembatani kedua probe dengan kabel jumper selama start-up dan lepaskan begitu board masuk sleep.
6. Masukkan arus yang kamu ukur, bersama lama waktu di setiap kondisi, ke rumus arus rata-rata di bawah.

Mengukur arus dan mAh terpakai dengan INA219

INA219 adalah modul sensor arus dan tegangan I2C yang kecil. Modul ini mengukur tegangan di resistor shunt 0,1 Ω pada board-nya dengan resolusi 12-bit, dan membaca arus sampai sekitar ±3,2 A di rangkaian hingga 26 V dengan resolusi kira-kira 0,1 mA. Alamat I2C bawaannya 0x40. Modul ini dipasang seri di jalur positif rangkaian yang diukur: positif baterai ke Vin+, dan Vin− ke input positif rangkaian. Arduino yang melakukan pengukuran diberi daya dari USB, dan GND-nya dihubungkan ke GND rangkaian yang diuji. Yang kamu butuhkan hanya library Adafruit INA219 dari Library Manager di Arduino IDE. INA219 tidak bisa membaca arus sleep di level mikroampere; ukur yang itu dengan rentang µA di multimeter.

1// INA219 ile akım, harcanan mAh ve pil ömrü / current, used mAh and battery life with INA219
2#include <Wire.h>
3#include <Adafruit_INA219.h>
4
5Adafruit_INA219 ina219;                    // varsayılan adres 0x40 / default address 0x40
6
7const float CAPACITY_MAH = 2500.0;         // pilin etiket kapasitesi / rated battery capacity
8const float USABLE = 0.85;                 // kullanılabilir oran / usable share
9
10float usedMah = 0;                         // toplam harcanan yük / total charge used
11float secMaMs = 0;                         // son saniyenin mA x ms toplamı / mA x ms of the last second
12unsigned long startMs, lastSample, lastPrint;
13
14void setup() {
15  Serial.begin(9600);
16  if (!ina219.begin()) {
17    Serial.println(F("INA219 bulunamadi / INA219 not found"));
18    while (true) {}
19  }
20  ina219.setCalibration_32V_1A();          // 1 A'e kadar ince ölçüm / finer steps up to 1 A
21  startMs = lastSample = lastPrint = millis();
22}
23
24void loop() {
25  unsigned long now = millis();
26
27  if (now - lastSample >= 10) {            // 10 ms'de bir örnek / one sample every 10 ms
28    float mA = ina219.getCurrent_mA();
29    secMaMs += mA * (now - lastSample);    // akım x süre / current x time
30    lastSample = now;
31  }
32
33  if (now - lastPrint >= 1000) {           // saniyede bir rapor / report once a second
34    lastPrint = now;
35    usedMah += secMaMs / 3600000.0;        // mA x ms -> mAh
36    secMaMs = 0;
37    float avgMa = usedMah / ((now - startMs) / 3600000.0);   // ortalama akım / average current
38    float volts = ina219.getBusVoltage_V() + ina219.getShuntVoltage_mV() / 1000.0;   // pil gerilimi / battery voltage
39
40    Serial.print(F("Pil / Battery: "));
41    Serial.print(volts, 2);
42    Serial.print(F(" V | Ort / Avg: "));
43    Serial.print(avgMa, 1);
44    Serial.print(F(" mA | Harcanan / Used: "));
45    Serial.print(usedMah, 2);
46    Serial.print(F(" mAh"));
47    if (avgMa > 0.5) {
48      Serial.print(F(" | Sure / Runtime: "));
49      Serial.print(CAPACITY_MAH * USABLE / avgMa, 1);   // saat / hours
50      Serial.print(F(" h"));
51    }
52    Serial.println();
53  }
54}

Kode ini membaca arus setiap 10 milidetik dan menjumlahkan hasil kali arus × waktu untuk mendapatkan mAh yang terpakai; dengan cara ini pulsa arus singkat seperti pengiriman Wi-Fi atau gerakan servo ikut masuk ke rata-rata. Sekali per detik, kode mencetak tegangan baterai, arus rata-rata sejauh ini, kapasitas yang terpakai, dan perkiraan waktu pakai berdasarkan 85% kapasitas tertulis ke Serial Monitor. Biarkan berjalan minimal satu siklus kerja penuh, misalnya cukup lama untuk mencakup satu siklus sleep dan bangun yang lengkap. Untuk beban di atas 1 A, pakai setCalibration_32V_2A(). Kode yang sama berjalan tanpa perubahan di ESP32 dengan GPIO 21 dan 22; untuk bantuan soal Serial Monitor, lihat Serial Monitor Arduino.

Menghitung waktu pakai: kapasitas / arus × efisiensi

Begitu arus rata-rata diketahui, rumus dasarnya sederhana: Waktu pakai (jam) = Kapasitas (mAh) / Arus rata-rata (mA) × Efisiensi. Faktor efisiensi 0,85 adalah titik awal yang bagus; faktor ini memperhitungkan kapasitas yang hilang pada arus tinggi dan di cuaca dingin, rangkaian yang berhenti sebelum baterai benar-benar kosong, dan penuaan baterai. Rumus ini berlaku kalau tidak ada regulator di antara baterai dan rangkaian, atau kalau regulatornya linear (regulator 5 V di Uno, AMS1117, 7805), karena di regulator linear arus input sama dengan arus output dan selisih tegangannya menjadi panas. Kalau kamu memakai konverter switching seperti modul boost atau buck, hitung dengan energi: Waktu pakai (jam) = Energi baterai (Wh) × Efisiensi / Daya beban (W). Di sini efisiensinya adalah efisiensi konverter 85–90% dikalikan porsi baterai yang bisa dipakai; 0,75–0,8 adalah angka yang realistis.

Untuk proyek yang tidur dan bangun, kamu perlu arus rata-ratanya dulu: Arus rata-rata = (Arus bangun × Waktu bangun + Arus sleep × Waktu sleep) / Waktu total. Misalnya, modul ESP32 polos yang bangun selama 5 detik setiap 10 menit dengan arus 120 mA, lalu tidur di 10 µA (0,01 mA) selama 595 detik sisanya, punya rata-rata (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA. Dengan 18650 3000 mAh, hasilnya 3000 / 1,01 × 0,85 ≈ 2520 jam, atau sekitar 3,5 bulan. Kalau kode yang sama berjalan di board pengembangan yang menarik 5 mA ketika sleep, rata-ratanya naik menjadi 5,96 mA dan waktu pakainya turun menjadi sekitar 18 hari. Daripada menghitung manual, kamu bisa memakai kalkulator umur baterai; cukup masukkan kapasitas, arus bangun dan sleep, serta interval bangunnya. Begitu arus rata-rata turun di bawah 0,1 mA, self-discharge (pengosongan sendiri) baterai juga menjadi faktor penentu: sel Li-ion kehilangan sekitar 2–3% kapasitasnya per bulan.

ESP32: mengukur waktu bangun untuk memperkirakan umur baterai

Konsumsi ESP32 bisa berbeda ribuan kali lipat tergantung mode kerjanya. Menurut datasheet Espressif, chip ini menarik hingga 240 mA ketika mengirim lewat Wi-Fi, sekitar 100 mA ketika menerima, 20–68 mA dengan Wi-Fi mati (modem sleep), sekitar 0,8 mA dalam light sleep, dan hanya 10 µA dalam deep sleep. Itulah sebabnya yang benar-benar menentukan umur baterai adalah lama waktu bangun: menyambung ke Wi-Fi sering butuh 1–3 detik, dan energi yang terpakai dalam beberapa detik itu lebih besar daripada berjam-jam sleep. Kode di bawah menyimpan lama board terjaga di memori RTC setiap kali bangun dan, dengan arus yang kamu ukur, menghitung arus rata-rata dan perkiraan umur baterai.

1// ESP32 derin uyku ve pil ömrü tahmini / ESP32 deep sleep and battery life estimate
2RTC_DATA_ATTR int bootCount = 0;               // derin uykuda silinmez / survives deep sleep
3RTC_DATA_ATTR unsigned long lastAwakeMs = 0;   // önceki uyanık süre / previous awake time
4
5const float ACTIVE_MA = 120.0;      // ölçtüğün uyanık akım / measured awake current
6const float SLEEP_MA = 0.01;        // ölçtüğün uyku akımı (10 µA) / measured sleep current (10 µA)
7const int SLEEP_S = 600;            // 10 dakika uyku / 10 minutes of sleep
8const float CAPACITY_MAH = 3000.0;  // 18650 kapasitesi / 18650 capacity
9const float USABLE = 0.85;          // kullanılabilir oran / usable share
10
11void setup() {
12  Serial.begin(115200);
13  bootCount++;
14
15  // Burada sensörü oku ve veriyi gönder / read the sensor and send the data here
16  delay(500);                       // örnek iş yükü / sample workload
17
18  if (lastAwakeMs > 0) {
19    float awakeS = lastAwakeMs / 1000.0;
20    float avgMa = (ACTIVE_MA * awakeS + SLEEP_MA * SLEEP_S) / (awakeS + SLEEP_S);
21    float days = CAPACITY_MAH * USABLE / avgMa / 24.0;
22    Serial.printf("Uyanis / Wake #%d, uyanik / awake: %.2f s\n", bootCount, awakeS);
23    Serial.printf("Ortalama / Average: %.3f mA, pil omru / battery life: %.0f gun / days\n", avgMa, days);
24  }
25
26  lastAwakeMs = millis();           // bu uyanışın süresi / duration of this wake
27  Serial.flush();
28  esp_sleep_enable_timer_wakeup((uint64_t)SLEEP_S * 1000000ULL);   // mikrosaniye / microseconds
29  esp_deep_sleep_start();           // loop() hiç çalışmaz / loop() never runs
30}
31
32void loop() {
33}

Pada bangun pertama, kode hanya menyimpan waktunya; di setiap bangun berikutnya, kode menghitung dan mencetak arus rata-rata dan umur baterai dalam hari berdasarkan waktu bangun sebelumnya. Ukur ACTIVE_MA dan SLEEP_MA di board-mu sendiri dengan multimeter lalu masukkan nilainya. millis() tidak menghitung waktu bootloader ketika start-up, jadi menambahkan margin 0,1–0,3 detik ke waktu bangun memberi hasil yang lebih realistis. Untuk detail mode sleep dan sumber bangun (wake-up), lihat deep sleep ESP32, dan untuk masalah restart yang mungkin muncul ketika memakai baterai, lihat error brownout ESP32.

Menghubungkan baterai secara seri dan paralel

Ketika kamu menghubungkan baterai secara seri (positif satu ke negatif berikutnya), tegangannya dijumlahkan dan kapasitasnya (mAh) tetap sama: empat baterai AA 1,5 V 2500 mAh yang diseri menghasilkan 6 V, 2500 mAh. Ketika kamu menghubungkannya secara paralel (positif dengan positif, negatif dengan negatif), tegangannya tetap sama dan kapasitasnya dijumlahkan: dua 18650 3000 mAh yang diparalel menghasilkan 3,7 V, 6000 mAh. Di kedua kasus, total energinya (Wh) bertambah sesuai jumlah sel. Untuk pack lithium, susunan ini ditulis dengan huruf S (seri) dan P (paralel); misalnya, 2S2P berarti pack empat sel yang terdiri dari dua pasangan paralel yang dihubungkan seri.

• Pakai sel yang identik: di pack seri atau paralel, pakai baterai dengan merek, kapasitas, umur, dan tingkat isi yang sama; sel yang lebih lemah akan habis lebih dulu daripada yang lain dan menjadi terbebani.
• Samakan tegangan sebelum memparalel: sebelum menghubungkan sel Li-ion secara paralel, selisih tegangan di antaranya tidak boleh lebih dari 0,1 V; kalau tidak, sel yang penuh akan mendorong arus besar yang tidak terkendali ke sel yang kosong.
• Pack lithium seri butuh proteksi: untuk pack 2S ke atas, pakai board BMS dengan balancing yang memantau setiap sel. Pack seri tidak bisa diisi dengan modul TP4056 yang dibuat untuk satu sel.
• Jangan campur sel isi ulang dan sekali pakai: jangan masukkan baterai alkaline dan NiMH ke pack yang sama; tegangan dan hambatan dalamnya berbeda.
• Sambungan paralel membagi beban: di pack 1S2P, setiap sel menanggung separuh arus, jadi pack paralel lebih awet sekaligus lebih dingin pada arus tinggi.

Apa itu rating C?

Rating C menunjukkan seberapa cepat baterai dikosongkan atau diisi dibandingkan kapasitasnya. 1C adalah arus yang mengosongkan baterai dalam 1 jam dan secara angka sama dengan kapasitasnya: untuk baterai 2000 mAh, 1C = 2 A, 0,5C = 1 A, dan 20C = 40 A. Menghitung waktunya juga mudah: pada 2C baterai kosong dalam sekitar 30 menit, pada 0,2C dalam 5 jam. Nilai seperti 25C atau 50C yang tercetak di LiPo drone dan RC menunjukkan arus pengosongan kontinu maksimum; LiPo 1000 mAh 25C bisa memberikan 25 A. Di sel 18650, nilai ini biasanya langsung ditulis dalam ampere: sel berkapasitas tinggi 3500 mAh memberikan 8–10 A, sedangkan sel high-drain 2500–3000 mAh memberikan 15–30 A secara kontinu. Aturan untuk pengisian lebih ketat: arus pengisian standar untuk sel lithium sekitar 0,5C, dan paling tinggi 1C. Modul TP4056 yang mengisi dengan 1 A cocok untuk 18650 2000 mAh, tetapi untuk LiPo kecil 300 mAh itu berarti sekitar 3C; dalam kasus itu kamu perlu mengganti resistor Rprog di modul untuk menurunkan arus pengisian.

Mengukur kapasitas baterai dengan Raspberry Pi Pico (MicroPython)

Sel 18650 berlabel 9900 mAh hampir selalu palsu; 18650 asli dengan kapasitas tertinggi di pasaran sekitar 3500–3600 mAh. Satu-satunya cara mengetahui kapasitas nyata baterai adalah mengosongkannya lewat beban yang nilainya diketahui dan menjumlahkan arusnya dari waktu ke waktu. Dengan Raspberry Pi Pico, satu resistor beban, dan satu MOSFET, kamu bisa membuat penguji kapasitas sederhana yang melakukan persis hal itu: Pico menyambungkan beban lewat MOSFET, mengukur tegangan baterai lewat pembagi tegangan, menghitung arus dengan I = V / R, dan memutus beban begitu tegangannya mencapai nilai cut-off. Nilai pembagi tegangannya bisa kamu cek dengan kalkulator pembagi tegangan, dan untuk detail pengkabelan MOSFET lihat Memakai MOSFET.

1from machine import ADC, Pin
2import time
3
4adc = ADC(26)                      # GP26: bölücünün orta noktası / divider midpoint
5load = Pin(15, Pin.OUT, value=0)   # GP15: MOSFET kapısı / MOSFET gate
6R_LOAD = 10.0                      # yük direnci, ohm (ölçüp yaz) / load resistor in ohms (measure it)
7DIV = 2.0                          # 100k + 100k bölücü / 100k + 100k divider
8CUTOFF = 3.0                       # Li-ion bitiş gerilimi / Li-ion end voltage
9CONV = 3.3 / 65535                 # ham değeri volta çevir / raw value to volts
10
11def battery_v():
12    total = 0
13    for _ in range(32):            # 32 ölçümün ortalaması / average of 32 readings
14        total += adc.read_u16()
15    return total / 32 * CONV * DIV
16
17mah = 0.0
18mwh = 0.0
19log = open("desarj.csv", "w")      # Pico'nun belleğine kaydedilir / saved to the Pico's flash
20log.write("dakika,volt,mA,mAh\n")
21load.value(1)                      # deşarjı başlat / start the discharge
22start = last = time.ticks_ms()
23
24while True:
25    time.sleep(30)
26    now = time.ticks_ms()
27    hours = time.ticks_diff(now, last) / 3600000
28    last = now
29    v = battery_v()                # yük altındaki gerilim / voltage under load
30    ma = v / R_LOAD * 1000         # I = V / R
31    mah += ma * hours
32    mwh += v * ma * hours
33    minutes = time.ticks_diff(now, start) / 60000
34    print("{:.0f} dk/min  {:.3f} V  {:.0f} mA  {:.0f} mAh  {:.2f} Wh".format(minutes, v, ma, mah, mwh / 1000))
35    log.write("{:.1f},{:.3f},{:.0f},{:.1f}\n".format(minutes, v, ma, mah))
36    log.flush()
37    if v <= CUTOFF:
38        load.value(0)              # yükü ayır, pili koru / disconnect the load, protect the cell
39        log.close()
40        print("Kapasite / Capacity: {:.0f} mAh, {:.2f} Wh".format(mah, mwh / 1000))
41        break

Setiap 30 detik, kode mengukur tegangan baterai di bawah beban, menghitung arusnya, dan menjumlahkan mAh dan Wh yang terpakai; hasilnya dicetak ke konsol Thonny sekaligus disimpan ke file desarj.csv di flash Pico (nama file bahasa Turki untuk “pengosongan”). Nanti file itu bisa kamu buka di Excel untuk menggambar kurva pengosongan (Mengirim data Arduino ke Excel). Dengan beban 10 Ω, menguji 18650 3000 mAh butuh sekitar 8–9 jam. Supaya hasilnya akurat, ukur resistor beban dengan multimeter dan masukkan sebagai R_LOAD, lalu bandingkan tegangan baterai dengan pembacaan multimeter dan sesuaikan faktor DIV. Untuk menguji AA NiMH, turunkan CUTOFF ke 1.0 V dan resistor beban ke 4,7 Ω. Pada 4,2 V, resistor beban membuang sekitar 1,8 W; pilih resistor dengan rating minimal 5 W, jauhkan dari permukaan yang mudah terbakar, dan jangan tinggalkan pengujian tanpa pengawasan. Kalau kamu belum tahu cara menginstal MicroPython di Pico, mulai dari Apa Itu Raspberry Pi Pico?.

Ide proyek yang memakai perhitungan baterai

• Sensor kebun yang bertahan berbulan-bulan: biarkan ESP32 dalam deep sleep, ukur kelembapan tanah sekali setiap jam, dan turunkan arus rata-rata ke bawah 1 mA.
• Voltmeter dengan indikator baterai: ukur tegangan baterai dan tampilkan sebagai persentase di LCD (Membuat Voltmeter Arduino).
• Pack yang pas untuk mobil robot: ukur arus motornya dan hitung berapa menit pack 18650 2S akan bertahan (Membuat mobil robot Arduino).
• Pencatat konsumsi daya: tulis pembacaan INA219 ke kartu SD untuk membuat profil energi harian sebuah perangkat (modul kartu SD).
• Stasiun uji kapasitas 18650: tambahkan layar OLED ke penguji Pico dan tampilkan mAh secara langsung.
• Stasiun cuaca bertenaga baterai: jalankan ESP32 yang mengirim data DHT11 setiap 10 menit selama berbulan-bulan dengan satu 18650.

Kesalahan umum dan cara memperbaikinya

Sekarang kamu sudah tahu beda mAh dan Wh, cara mengukur arus proyekmu, dan cara menghitung berapa jam atau hari sebuah baterai akan bertahan. Sebagai langkah berikutnya, lihat Memberi daya Arduino dengan baterai dan Mengisi 18650 dengan TP4056. Di aplikasi BlueGrays kamu akan menemukan proyek bertenaga baterai seperti deep sleep ESP32 untuk hemat baterai, voltmeter digital dengan layar LCD, mobil kendali Bluetooth, dan robot penghindar rintangan, masing-masing dengan skema rangkaian dan kode langkah demi langkah.