mAh Ne Demek? Pil Kapasitesi, Wh ve Çalışma Süresi Hesabı

mAh ne demek sorusunun kısa cevabı şu: mAh (miliamper-saat), bir pilin ya da bataryanın ne kadar elektrik yükü depoladığını gösteren kapasite birimidir. 1 mAh, 1 miliamperlik akımın 1 saat boyunca akması demektir; yani 2000 mAh yazan bir pil, kuramsal olarak 20 mA çeken bir devreyi 100 saat, 200 mA çeken bir devreyi 10 saat besler. Ancak bu değer tek başına yeterli değildir: pilin gerilimi, çekilen akım, sıcaklık ve pil ile devre arasındaki regülatör, gerçek çalışma süresini büyük ölçüde değiştirir.

Arduino, ESP32 ya da Raspberry Pi Pico ile pilli bir proje yaptığında ilk soru hep aynıdır: Bu pil kaç saat, kaç gün dayanır? Bu rehberde mAh ve Wh kavramlarını, AA, 9V, 18650 ve LiPo pillerin gerçek kapasitelerini, projenin akım tüketimini multimetre ve INA219 ile ölçmeyi, çalışma süresini formülle hesaplamayı, pilleri seri ve paralel bağlamayı, C oranını ve 9V pilin neden kötü bir seçim olduğunu gerçek sayılarla öğreneceksin.

mAh ne demek? Pil kapasitesinin anlamı

Akım amper (A) ile, kapasite ise amper-saat (Ah) ile ölçülür. Küçük piller için bunun binde biri olan miliamper-saat kullanılır: 1 Ah = 1000 mAh. Fizikteki karşılığı elektrik yüküdür; 1 mAh, 3,6 coulomb yüke eşittir. Üreticiler kapasiteyi belirli bir deşarj akımında ve belirli bir bitiş geriliminde ölçer. Akım büyüdükçe pilin iç direncinde daha fazla gerilim düşer, kimyasal tepkime yetişemez ve bitiş gerilimine daha erken ulaşılır; bu yüzden aynı pil yüksek akımda daha az mAh verir. Soğuk hava da kapasiteyi düşürür; alkalin piller özellikle 0 °C'nin altında belirgin şekilde zayıflar. Aşağıdaki tablo, Energizer'ın AA alkalin pil verilerine göre çekilen akımın kapasiteyi nasıl değiştirdiğini gösteriyor (0,8 V'a kadar, 21 °C).

Tablodaki fark çarpıcıdır: akımı 20 katına çıkardığında süre 20 kat değil, 40 kat kısalır. Bu nedenle etiketteki mAh değerini en iyi durum olarak düşün. Gerçek projelerde buna bir de devrenin pil tamamen boşalmadan durması eklenir: Arduino Uno'nun regülatörü girişte 7 V'un altına inildiğinde 5 V'u koruyamaz, tek hücreli bir lityum pil ise ömrü kısalmasın diye 3,0–3,3 V civarında kesilmelidir. Pilin içinde kalan bu enerji hiç kullanılmaz.

Wh ne demek? mAh ile farkı

mAh yalnızca yük miktarını söyler; pilin enerjisini bulmak için gerilimle çarpman gerekir. Enerji birimi watt-saattir (Wh) ve formülü şudur: Wh = mAh × V / 1000. Örneğin 3,7 V'luk 3000 mAh bir 18650 hücre 3,7 × 3 = 11,1 Wh enerji taşır. 2500 mAh'lik bir AA kalem pil kâğıt üzerinde 1,5 × 2,5 = 3,75 Wh eder, ama alkalin pilin ortalama gerilimi deşarj boyunca 1,2–1,3 V'a indiği için gerçek değer 3 Wh civarındadır. Farklı gerilimdeki pilleri yalnızca mAh ile karşılaştırmak bu yüzden yanıltıcıdır: 550 mAh'lik bir 9V pil, 2500 mAh'lik AA'dan çok küçük görünse de yaklaşık 4 Wh ile ondan biraz daha fazla enerji taşır. Hangisinin projende daha uzun dayanacağı ise aradaki regülatörün türüne bağlıdır; bunu süre hesabı bölümünde göreceksin. Güç ve akım arasındaki ilişkiyi (P = V × I) hızlıca hesaplamak için Ohm kanunu hesaplayıcısını kullanabilirsin.

AA, 9V, 18650 ve LiPo pil karşılaştırma tablosu

Tabloyu okurken şunu hatırla: ağırlığına göre en fazla enerjiyi 18650 ve LiPo gibi lityum hücreler taşır; tek bir 18650, dört AA alkalin pilin toplam enerjisine yakın bir enerjiyi yaklaşık yarı ağırlıkta taşır. Alkalin piller düşük akımlı ve uzun süre rafta bekleyecek cihazlar için iyidir, çünkü yılda yalnızca yüzde birkaç kapasite kaybederler; motor ya da servo gibi yüksek akım isteyen yüklerde ise gerilimleri hızla çöker. NiMH şarjlı piller 1,2 V'luk düşük gerilimlerine rağmen yüksek akımı rahat verir; düşük deşarjlı (LSD) türleri aylarca dolu kalır. CR2032 düğme pil ise yalnızca mikroamper seviyesinde çalışan saat modülleri ve uyuyan sensörler içindir; Wi-Fi'ye bağlanan bir ESP32'yi asla besleyemez.

9V pil neden kötü bir seçim?

Kare 9V pil, klipsli kablosu Arduino'nun DC jakına kolayca takıldığı için başlangıç setlerinde sık görülür, ama pille çalışan bir Arduino projesi için en kötü seçeneklerden biridir. İçinde seri bağlı altı küçük hücre bulunduğundan kapasitesi yalnızca 400–600 mAh'tir. Energizer'ın verilerine göre 9V alkalin pil 4,8 V'a kadar boşaltıldığında 10 mA'de yaklaşık 600, 25 mA'de 570, 50 mA'de ise yalnızca 450 mAh verir. Arduino Uno'nun regülatörü ise DC jaktan en az 7 V ister; pilin gerilimi yük altında birkaç saat içinde bu sınırın altına iner ve geri kalan enerji kullanılamaz. Bu yüzden yaklaşık 50 mA çeken bir Uno, 9V pille genellikle yalnızca birkaç saat, çoğu zaman 4–8 saat çalışır.

• Düşük kapasite: 6×AA paketin 2000–2500 mAh'ine karşılık yalnızca 400–600 mAh; aynı 9 V gerilimde dört kattan fazla kısa süre.
• Yüksek iç direnç: Bir servo dönmeye başladığında ya da röle çektiğinde gerilim bir anda çöker ve Arduino resetlenir.
• Regülatör kaybı: Uno'nun lineer regülatörü 9 V'u 5 V'a düşürürken aradaki 4 V'u ısıya çevirir; 50 mA'de pilden çekilen 0,45 W'ın yaklaşık 0,2 W'ı boşa gider.
• Pahalı enerji: Wh başına maliyeti AA kalem pillerden belirgin şekilde yüksektir; şarjlı NiMH 9V pillerin kapasitesi ise 170–300 mAh'e kadar düşer.
• Nerede iyi? Duman dedektörü, multimetre ya da birkaç mA çekip uzun süre bekleyen cihazlarda 9V pil gayet uygundur. Arduino için 6×AA, 2S 18650 paketi ya da powerbank tercih et; ayrıntılar Arduino pil ile çalıştırma yazısında.

Arduino projesinin akım tüketimini ölçmek

Pil ömrünü hesaplamak için önce projenin ne kadar akım çektiğini bilmen gerekir. Tahmin etmek yerine ölçmek en doğrusudur, çünkü kartın kendi tüketimi, güç LED'leri ve regülatörler çoğu zaman sensörlerden daha fazla akım çeker. En kolay yol, multimetreyi pil ile devre arasına seri bağlamaktır. Uyku ve uyanma döngüsü olan projelerde ise kısa akım tepelerini ve gerçek ortalamayı yakalamak için INA219 gibi bir akım sensörü daha iyi sonuç verir. Multimetrenin kademeleri ve soketleri hakkında ayrıntılı bilgi için multimetre nasıl kullanılır yazısına bakabilirsin.

1. Devrenin enerjisini kes; kırmızı probu multimetrenin mA soketine, siyah probu COM soketine tak. Akımın 200 mA'i geçebileceğini düşünüyorsan önce 10A soketiyle başla.
2. Kademe anahtarını DC akım (A⎓) konumuna, otomatik kademeli değilse 200 mA kademesine getir.
3. Pilin artı kablosunu devreden ayır; kırmızı probu pilin artısına, siyah probu devrenin artı girişine bağla. Böylece tüm akım multimetrenin içinden geçer.
4. Devreyi çalıştır ve değeri oku. Servo dönerken, Wi-Fi bağlanırken ya da röle çekerken de ayrı ayrı ölç ve her durumun akımını not et.
5. Uyku akımı mikroamper seviyesindeyse µA kademesine geç. Kart açılırken bu kademede yeterli akım alamayabilir; açılışta probları bir jumper kabloyla köprüle, kart uykuya geçince kabloyu çıkar.
6. Ölçtüğün akımları, her durumda geçen sürelerle birlikte aşağıdaki ortalama akım formülüne yerleştir.

INA219 ile akım ve harcanan mAh ölçmek

INA219, I2C ile çalışan küçük bir akım ve gerilim ölçüm modülüdür. Kart üzerindeki 0,1 Ω'luk şönt direnç üzerinde düşen gerilimi 12 bit çözünürlükle ölçer; 26 V'a kadar gerilimdeki devrelerde yaklaşık ±3,2 A'e kadar akımı yaklaşık 0,1 mA hassasiyetle okur. Varsayılan I2C adresi 0x40'tır. Modülü ölçülen devrenin artı hattına seri bağlarsın: pilin artısı Vin+ ucuna, Vin− ucu ise devrenin artı girişine gider. Ölçümü yapan Arduino USB'den beslenir ve GND'si ölçülen devrenin GND'sine bağlanır. Arduino IDE'de Kütüphane Yöneticisi'nden Adafruit INA219 kütüphanesini kurman yeterli. INA219 mikroamper seviyesindeki uyku akımlarını çözemez; onları multimetrenin µA kademesiyle ölç.

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}

Kod her 10 milisaniyede bir akımı okur ve akım × süre çarpımlarını toplayarak harcanan mAh değerini bulur; bu yöntem Wi-Fi gönderimi ya da servo hareketi gibi kısa akım darbelerini de ortalamaya katar. Saniyede bir pil gerilimini, o ana kadarki ortalama akımı, harcanan kapasiteyi ve etiket kapasitesinin %85'ine göre tahmini çalışma süresini Seri Monitör'e yazar. Ölçümü en az bir tam çalışma döngüsü boyunca, örneğin bir uyku ve uyanma döngüsünü kapsayacak kadar açık bırak. 1 A'i aşan yüklerde setCalibration_32V_2A() kullan. Aynı kod ESP32'de GPIO 21 ve 22 pinleriyle değiştirilmeden çalışır; Seri Monitör'ün kullanımı için Arduino Serial Monitor yazısına göz atabilirsin.

Çalışma süresi hesabı: kapasite / akım × verim

Ortalama akımı bildiğinde temel formül basittir: Çalışma süresi (saat) = Kapasite (mAh) / Ortalama akım (mA) × Verim. Verim katsayısı için 0,85 iyi bir başlangıçtır; bu katsayı yüksek akımda ve soğukta kaybolan kapasiteyi, devrenin pil tamamen bitmeden durmasını ve pilin yaşlanmasını hesaba katar. Bu formül, pil ile devre arasında hiç regülatör yoksa ya da lineer bir regülatör (Uno'nun 5 V regülatörü, AMS1117, 7805) varsa geçerlidir, çünkü lineer regülatörde giriş akımı çıkış akımına eşittir ve gerilim farkı ısıya dönüşür. Boost ya da buck gibi anahtarlamalı bir dönüştürücü kullanıyorsan hesabı enerjiyle yap: Süre (saat) = Pil enerjisi (Wh) × Verim / Yükün gücü (W). Burada verim, dönüştürücünün %85–90'lık verimiyle pilin kullanılabilir payının çarpımıdır; 0,75–0,8 almak gerçekçidir.

Uyuyup uyanan projelerde önce ortalama akımı bulman gerekir: Ortalama akım = (Uyanık akım × Uyanık süre + Uyku akımı × Uyku süresi) / Toplam süre. Örneğin 10 dakikada bir 5 saniye uyanıp 120 mA çeken, kalan 595 saniyede 10 µA (0,01 mA) ile uyuyan çıplak bir ESP32 modülünün ortalaması (120 × 5 + 0,01 × 595) / 600 ≈ 1,01 mA'dir. 3000 mAh'lik bir 18650 ile bu, 3000 / 1,01 × 0,85 ≈ 2520 saat, yani yaklaşık 3,5 ay eder. Aynı kod uykuda 5 mA çeken bir geliştirme kartında çalışırsa ortalama 5,96 mA'e çıkar ve süre yaklaşık 18 güne düşer. Bu hesabı elle yapmak yerine pil ömrü hesaplayıcısını kullanabilirsin; kapasiteyi, uyanık ve uyku akımını, uyanma aralığını girmen yeterli. Ortalama akım 0,1 mA'in altına indiğinde artık pilin kendi kendine boşalması da belirleyici olur: bir Li-ion hücre ayda yaklaşık %2–3 kapasite kaybeder.

ESP32: uyanık süreyi ölçüp pil ömrünü tahmin etmek

ESP32'nin tüketimi çalışma moduna göre binlerce kat değişir. Espressif'in veri sayfasına göre yonga Wi-Fi ile veri gönderirken 240 mA'e varan, alırken yaklaşık 100 mA, Wi-Fi kapalıyken (modem uykusu) 20–68 mA, hafif uykuda yaklaşık 0,8 mA, derin uykuda ise yalnızca 10 µA çeker. Bu yüzden pil ömrünü belirleyen asıl şey uyanık kalınan süredir: Wi-Fi'ye bağlanmak çoğu zaman 1–3 saniye sürer ve bu kısa sürede harcanan enerji, saatlerce süren uykuda harcanandan fazladır. Aşağıdaki kod her uyanışta ne kadar uyanık kaldığını RTC belleğinde saklar ve ölçtüğün akım değerleriyle ortalama akımı ve tahmini pil ömrünü hesaplar.

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}

İlk uyanışta yalnızca süre kaydedilir; sonraki her uyanışta bir önceki uyanık süreyle ortalama akım ve gün cinsinden pil ömrü hesaplanıp yazdırılır. ACTIVE_MA ve SLEEP_MA değerlerini kendi kartında multimetreyle ölçüp yaz. millis() açılıştaki önyükleyici (bootloader) süresini saymaz; uyanık süreye 0,1–0,3 saniyelik bir pay eklemek daha gerçekçi sonuç verir. Uyku modlarının ve uyandırma kaynaklarının ayrıntıları için ESP32 deep sleep yazısına, pille beslerken karşılaşabileceğin yeniden başlama sorunları için ESP32 brownout hatası yazısına bakabilirsin.

Seri ve paralel pil bağlama

Pilleri seri bağladığında (birinin artısı diğerinin eksisine) gerilimler toplanır, kapasite (mAh) aynı kalır: 1,5 V'luk 2500 mAh dört AA pil seri bağlanınca 6 V, 2500 mAh olur. Paralel bağladığında (artılar kendi arasında, eksiler kendi arasında) gerilim aynı kalır, kapasiteler toplanır: 3000 mAh'lik iki 18650 paralel bağlanınca 3,7 V, 6000 mAh olur. Her iki durumda da toplam enerji (Wh) hücre sayısıyla birlikte artar. Lityum paketlerde bu düzen kısaca S (seri) ve P (paralel) harfleriyle yazılır; örneğin 2S2P, iki paralel çiftin seri bağlanmasıyla oluşan dört hücreli bir paket demektir.

• Aynı hücreleri kullan: Seri ya da paralel pakette aynı marka, aynı kapasite, aynı yaş ve aynı doluluktaki pilleri kullan; zayıf hücre ötekilerden önce biter ve zorlanır.
• Paralelden önce gerilimleri eşitle: Li-ion hücreleri paralel bağlamadan önce aralarındaki gerilim farkı 0,1 V'u geçmemeli; aksi halde dolu hücre boş olana kontrolsüz büyük bir akım basar.
• Seri lityum paket koruma ister: 2S ve üzeri paketlerde her hücreyi ayrı izleyen, dengeleme özellikli bir BMS kartı kullan. Tek hücre şarj eden TP4056 modülü ile seri paket şarj edilmez.
• Şarjlı ve şarjsız pili karıştırma: Alkalin ve NiMH pilleri aynı pakete koyma; gerilimleri ve iç dirençleri farklıdır.
• Paralel bağlantı yükü paylaştırır: 1S2P pakette her hücre akımın yarısını taşır; bu yüzden paralel paket hem daha uzun dayanır hem de yüksek akımda daha az ısınır.

C oranı nedir?

C oranı, bir pilin kapasitesine göre ne kadar hızlı boşaltıldığını ya da şarj edildiğini gösterir. 1C, pili 1 saatte tamamen boşaltacak akımdır ve sayısal olarak kapasiteye eşittir: 2000 mAh'lik bir pil için 1C = 2 A, 0,5C = 1 A, 20C = 40 A'dir. Süreyi bulmak da kolaydır: 2C'de pil yaklaşık 30 dakikada, 0,2C'de 5 saatte biter. Drone ve RC model LiPo'larının üzerinde yazan 25C, 50C gibi değerler en yüksek sürekli deşarj akımını gösterir; 1000 mAh 25C bir LiPo 25 A verebilir. 18650 hücrelerde bu değer genellikle doğrudan amper olarak yazılır: 3500 mAh'lik yüksek kapasiteli hücreler 8–10 A, 2500–3000 mAh'lik yüksek akımlı hücreler 15–30 A sürekli akım verir. Şarjda kural daha sıkıdır: lityum hücreler için standart şarj akımı 0,5C civarıdır, en fazla 1C'dir. 1 A ile şarj eden bir TP4056 modülü 2000 mAh'lik bir 18650 için uygundur, ama 300 mAh'lik küçük bir LiPo'yu yaklaşık 3C ile zorlar; bu durumda modülün Rprog direncini değiştirip şarj akımını düşürmen gerekir.

Raspberry Pi Pico ile pil kapasitesi ölçmek (MicroPython)

Üzerinde 9900 mAh yazan 18650 hücreler neredeyse her zaman sahtedir; piyasadaki en yüksek kapasiteli gerçek 18650'ler 3500–3600 mAh civarındadır. Bir pilin gerçek kapasitesini öğrenmenin tek yolu, onu bilinen bir yük üzerinden boşaltıp akımı zamanla toplamaktır. Raspberry Pi Pico, bir yük direnci ve bir MOSFET ile bunu yapan basit bir kapasite test cihazı kurabilirsin: Pico, MOSFET ile yükü devreye alır, pil gerilimini bir gerilim bölücü üzerinden ölçer, akımı I = V / R ile hesaplar ve gerilim bitiş değerine inince yükü ayırır. Bölücü değerlerini gerilim bölücü hesaplayıcısı ile kontrol edebilir, MOSFET bağlantısının ayrıntıları için MOSFET kullanımı yazısına bakabilirsin.

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

Kod her 30 saniyede bir pil gerilimini yük altında ölçer, akımı hesaplar, harcanan mAh ve Wh değerlerini toplar; sonuçları hem Thonny konsoluna yazar hem de Pico'nun belleğindeki desarj.csv dosyasına kaydeder. Bu dosyayı sonra Excel'de açıp deşarj eğrisini çizebilirsin (Arduino'dan Excel'e veri aktarma). 10 Ω'luk yükle 3000 mAh'lik bir 18650'nin testi yaklaşık 8–9 saat sürer. Doğru sonuç için yük direncini multimetreyle ölçüp R_LOAD değerine yaz ve pil gerilimini multimetreyle karşılaştırarak DIV katsayısını düzelt. AA NiMH test edeceksen CUTOFF değerini 1,0 V'a, yük direncini 4,7 Ω'a indir. Yük direnci 4,2 V'ta yaklaşık 1,8 W ısı üretir; en az 5 W'lık bir direnç seç, yanıcı yüzeylerden uzak tut ve testi gözetimsiz bırakma. Pico'ya MicroPython yüklemeyi bilmiyorsan Raspberry Pi Pico nedir? yazısından başlayabilirsin.

Pil hesabıyla proje fikirleri

• Aylarca çalışan bahçe sensörü: ESP32'yi derin uykuda tutup saatte bir toprak nemini ölç ve ortalama akımı 1 mA'in altına indir.
• Pil göstergeli voltmetre: Pil gerilimini ölçüp LCD ekranda yüzde olarak göster (Arduino voltmetre yapımı).
• Robot araba için doğru paket: Motorların akımını ölçüp 2S 18650 paketin kaç dakika dayanacağını hesapla (Arduino robot araba yapımı).
• Güç tüketimi kaydedici: INA219 ölçümlerini SD karta yazarak bir cihazın günlük enerji profilini çıkar (SD kart modülü).
• 18650 kapasite test istasyonu: Pico'lu test devresine bir OLED ekran ekleyip mAh değerini canlı göster.
• Pilli hava istasyonu: DHT11 verisini 10 dakikada bir gönderen bir ESP32'yi tek bir 18650 ile aylarca çalıştır.

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

Artık mAh ile Wh'in farkını, projenin akımını nasıl ölçeceğini ve pilin kaç saat ya da kaç gün dayanacağını hesaplamayı biliyorsun. Bir sonraki adım olarak Arduino'yu pille çalıştırma ve TP4056 ile 18650 şarjı yazılarına göz atabilirsin. BlueGrays uygulamasında ESP32 deep sleep ile pil tasarrufu, LCD ekranlı dijital voltmetre, Bluetooth kontrollü robot araba ve engelden kaçan robot gibi pille çalışan projeleri adım adım devre şemaları ve kodlarıyla bulabilirsin.