ESP32 ile düşük güç tüketimli akıllı ev sensörü nasıl yapılır?

Question

Evdeki nem ve sıcaklık sensörlerini sürekli pille çalıştırmakta zorlanıyorum. ESP32'nin uyku modlarını kullanarak gerçekten haftalarca dayanan bir sistem kurmak mümkün mü, yoksa belli başlı sensörler çok mu enerji harcar?

Answer 1

Merhaba sevgili akıllı ev meraklıları ve düşük güç tüketimi arayışında olan değerli okuyucular,

Bugün sizin de benim gibi sıkça karşılaştığınız, akıllı ev sensörlerinin en can sıkıcı sorunlarından birine, yani pil ömrüne odaklanacağız. Özellikle nem ve sıcaklık gibi sürekli izlenmesi gereken veriler söz konusu olduğunda, pillerin haftalar yerine günler içinde bitmesi, projenin tüm cazibesini kaybetmesine neden olabiliyor. Ama size harika bir haberim var: ESP32'nin gücünü ve özellikle uyku modlarını doğru kullanarak, haftalarca, hatta aylar boyunca pille çalışan sensörler inşa etmek hayal değil! Gelin, bu yolculuğa birlikte çıkalım.

Giriş: Akıllı Evin Pil Derdi ve ESP32'nin Kurtarıcı Rolü

Hepimiz evlerimizi daha akıllı, daha konforlu hale getirmek istiyoruz. Oda sıcaklığını, nem seviyesini, hava kalitesini anlık olarak bilmek ve buna göre otomasyonlar kurmak harika bir fikir. Ancak bu sensörleri her yere kablo çekmeden, pille çalıştırmak istediğimizde, pil değişim döngüsü kısa sürede bir kabusa dönüşebiliyor. İşte tam bu noktada ESP32, bize olağanüstü yetenekler sunuyor.

ESP32, güçlü Wi-Fi ve Bluetooth özellikleriyle, çift çekirdekli işlemcisiyle ve zengin çevresel birimleriyle (GPIO, ADC, I2C, SPI vb.) akıllı ev projeleri için biçilmiş kaftan. Ancak, bu kadar gücün bir bedeli var: Aktif durumda yüksek enerji tüketimi. Peki, bu güçlü işlemciyi nasıl düşük güç tüketimli bir canavara dönüştürebiliriz? İşte sır burada: Uyku Modları!

Neden ESP32? Güçlü Bir Platform, Zayıf Bir Tüketim Canavarı mı?

ESP32, teoride yüksek akım çeken bir mikrodenetleyici olabilir. Wi-Fi modülü devredeyken 200-300 mA'ya kadar çıkabilen anlık akım çekimleri görmek şaşırtıcı değil. Bu değerler, küçük bir pille birkaç saat içinde pilinizi bitirebilir. Ancak ESP32'nin tasarımında, bu sorunu çözmek için çeşitli güç yönetimi modları bulunmaktadır. Bu modları doğru anladığımızda ve uyguladığımızda, ESP32'nin gelişmiş uyku modları (özellikle Deep Sleep) sayesinde ortalama akım tüketimini mikroamper seviyelerine çekebiliriz. Bu da bize haftalarca, hatta aylarca süren pil ömrü kapılarını aralar.

Anahtar: ESP32'nin Uyku Modları ve Doğru Kullanım

ESP32'nin en önemli özelliği, farklı güç tasarrufu modlarına sahip olmasıdır. Bunlar arasında en çok öne çıkanlar Light Sleep ve Deep Sleep modlarıdır.

Light Sleep vs. Deep Sleep: Farkı Anlamak

• Light Sleep (Hafif Uyku): CPU duraklatılır, Wi-Fi ve Bluetooth durumları korunabilir. Uyanma süresi Deep Sleep'e göre çok daha kısadır. Ancak güç tüketimi Deep Sleep'ten daha fazladır (genellikle birkaç mA seviyesinde). Anlık veri gönderip tekrar uykuya geçmesi gereken, ancak daha sık uyanması gereken uygulamalar için uygundur.
• Deep Sleep (Derin Uyku): ESP32'nin kalbi olan ana CPU tamamen kapatılır. Sadece RTC (Gerçek Zamanlı Saat) kontrolcüsü ve bir miktar RTC belleği aktif kalır. Wi-Fi ve Bluetooth bağlantıları kesilir, yeniden başlatıldığında tekrar kurulması gerekir. Güç tüketimi en düşük seviyededir (genellikle 5-20 mikroamper civarında). Bizim gibi haftalarca pil ömrü arayanlar için olmazsa olmaz moddur.

Deep Sleep Nasıl Çalışır?

Deep Sleep modunda ESP32, "uyandırma" tetikleyicisi bekler. Bu tetikleyiciler şunlar olabilir:

• Zamanlayıcı (Timer): Belirli bir süre sonra uyanmak için kullanılır. En sık kullandığımız yöntem budur. Örneğin, her 10 dakikada bir uyanıp veri gönderebiliriz.
• Harici Kesme (External Wakeup): Bir GPIO pinine gelen sinyal ile uyanma. Örneğin, bir hareket sensöründen (PIR) gelen sinyal ile uyanıp hareketi bildirebilir.
• Dokunmatik Sensör (Touch Sensor): ESP32'nin dahili dokunmatik sensörleri ile uyanma.

Deep Sleep'e geçmek için Arduino IDE'de basitçe ESP.deepSleep(uyku_suresi_mikrosaniye); komutunu kullanırız. Uyanma zamanlayıcısını ayarlamak için ise esp_sleep_enable_timer_wakeup(uyku_suresi_mikrosaniye); fonksiyonunu çağırırız.

Sensör Seçimi: Güç Tüketimini Göz Ardı Etmeyin!

Burada pek çok kişinin gözden kaçırdığı, ancak pil ömrü için kritik öneme sahip bir noktaya değinmek istiyorum: Sensörün kendisinin güç tüketimi!

Nem ve Sıcaklık Sensörleri Mercek Altında

• DHT11/DHT22: Bu sensörler popülerdir, ucuzdur ve kullanımı kolaydır. Ancak, sürekli güç altında olduklarında bile az da olsa akım çekerler (DHT22 için yaklaşık 0.5-1 mA). Bu, Deep Sleep modunda ESP32'nin tükettiği mikroamperlerin yanında bile oldukça yüksek bir değerdir. Eğer 10 dakikada bir okuma yapıp geri kalan zamanlarda sensörü uykuya gönderemiyorsanız, bu sensörler pil ömrünüzü ciddi şekilde kısaltacaktır. Maalesef, bu tür tek kablolu sensörleri ESP32 Deep Sleep'e geçtikten sonra tamamen kapatmak zordur.
• BME280 / BMP280 / SHT30 (I2C Sensörler): İşte düşük güç tüketimli projeler için gerçek kahramanlar! Bu sensörler I2C protokolü üzerinden haberleşir ve en güzeli, VCC (güç) pinlerine giden elektriği tamamen keserek kapatılabilirler! Bu ne demek? ESP32 Deep Sleep'teyken, sensöre hiç elektrik gitmez ve sensör sıfır akım çeker. ESP32 uyandığında, sensöre güç verir, okumayı yapar ve tekrar sensörün gücünü keser. Bu yöntemle sensörün kendi tüketimini neredeyse tamamen ortadan kaldırabilirsiniz.

Tavsiye: Nem ve sıcaklık sensörü arıyorsanız, BME280 (sıcaklık, nem, basınç) veya sadece sıcaklık ve basınç okuyan BMP280'i tercih edin. Bunlar küçük, doğru ve en önemlisi güç kontrollü çalışmaya çok uygunlardır.

Adım Adım Düşük Güç Tüketimli Sensör Tasarımı

Şimdi gelelim işin pratiğine. Nasıl bir yol izlemeliyiz?

1. Donanım Seçimi ve Bağlantıları

• ESP32 Geliştirme Kartı: Başlangıç için bir ESP32 DevKitC gibi bir kart kullanabilirsiniz. Ancak nihai ürününüzde, kart üzerindeki USB-UART çipi (CP2104, CH340 gibi), güç LED'leri ve bazı voltaj regülatörleri Deep Sleep modunda bile gereksiz akım çekebilir. En ideal olanı, çıplak bir ESP32 modülü (ESP32-WROOM-32D gibi) ve harici, verimli bir güç kaynağı devresi kullanmaktır. Eğer geliştirme kartı kullanıyorsanız, pil ömrünü optimize etmek için kart üzerindeki güç LED'ini devre dışı bırakmayı düşünebilirsiniz (genellikle bir direnci sökerek veya keserek).
• Pil: Projenizin boyutuna ve gönderim sıklığına göre 500 mAh - 2000 mAh arası bir LiPo pil genellikle yeterli olacaktır.

• Sensör Güç Kontrolü: I2C sensörünüzü ESP32'nin bir GPIO pini üzerinden kontrol edilen bir MOSFET veya transistör aracılığıyla besleyin. Böylece ESP32 uykuya geçtiğinde sensöre giden elektriği tamamen kesebilirsiniz.

  Basit Bağlantı Şeması (Sensör Güç Kontrolü İçin):
  ESP32 GPIO (örn: D13) -> MOSFET Gate (Kapı)
  LiPo Pozitif (+) -> MOSFET Source (Kaynak)
  MOSFET Drain (Oluk) -> Sensör VCC
  Sensör GND -> ESP32 GND
  Sensör SDA -> ESP32 SDA
  Sensör SCL -> ESP32 SCL

2. Yazılım Stratejisi: Az ve Öz Çalışma Prensibi

Düşük güç tüketimi için yazılım tarafında temel prensibimiz şudur: Minimum sürede maksimum işi yap ve tekrar uykuya geç.

1. Uyku Modundan Uyanma: setup() fonksiyonu her uyandığında çalışacaktır. Burada, uyanmanın nedenini kontrol edebilirsiniz (timer mı, external wakeup mı?).
2. Sensöre Güç Ver: MOSFET ile kontrol ettiğiniz sensöre GPIO pinini HIGH yaparak güç verin.
3. Sensör Verilerini Oku: Sensörden gerekli verileri alın. Bu işlem genellikle birkaç milisaniye sürer.
4. Sensörün Gücünü Kes: GPIO pinini LOW yaparak sensöre giden elektriği kesin. Bu çok önemli bir adımdır.
5. Wi-Fi Bağlantısını Kur: Sadece veri göndermeniz gerektiğinde Wi-Fi bağlantısını kurun. WiFi.begin(SSID, PASSWORD);
6. Veriyi Gönder: Veriyi bir sunucuya (MQTT broker, HTTP POST endpoint vb.) gönderin. MQTT, küçük paketler halinde veri gönderimi için daha verimlidir.
7. Wi-Fi Bağlantısını Kapat: Veriyi gönderdikten sonra WiFi.disconnect(true); WiFi.mode(WIFI_OFF); komutlarıyla Wi-Fi'yi tamamen kapatın. Bu, önemli bir güç tasarrufu sağlar.
8. Deep Sleep'e Geç: Belirlediğiniz süre (örn: 10 dakika = 600.000.000 mikrosaniye) sonra uyanmak üzere esp_sleep_enable_timer_wakeup() ve ESP.deepSleep() komutları ile uykuya geçin.

`cpp

include <Wire.h>

include <Adafruit_Sensor.h>

include <Adafruit_BME280.h>

include <WiFi.h>

// WiFi Bilgileri
const char ssid = "WIFI_ADINIZ";
const char password = "WIFI_ŞİFRENİZ";

// Sensör Güç Kontrol Pini
const int SENSOR_POWER_PIN = 13; // Bir MOSFET'i kontrol eden GPIO pini

// BME280 Sensörü
Adafruit_BME280 bme; // I2C ile varsayılan adres 0x76

// Uyku Süresi (10 Dakika = 600 saniye = 600.000.000 mikrosaniye)

define DEEP_SLEEP_TIME_SEC 600

RTC_DATA_ATTR int bootCount = 0; // RTC belleğinde saklanır, Deep Sleep'ten sonra değerini korur

void setup() {
Serial.begin(115200);
delay(100);

// Uyanma sayacını artır
++bootCount;
Serial.printf("Uyandı #%d kez\n", bootCount);

// Sensöre güç ver
pinMode(SENSOR_POWER_PIN, OUTPUT);
digitalWrite(SENSOR_POWER_PIN, HIGH);
delay(100); // Sensörün stabilize olması için kısa bir bekleme

// BME280 başlat
if (!bme.begin(0x76)) {

Serial.println("BME280 bulunamadı! Bağlantıları kontrol edin.");
digitalWrite(SENSOR_POWER_PIN, LOW); // Hata durumunda sensör gücünü kes
// Hata durumunda yine de uykuya geç
Serial.printf("Deep Sleep'e geçiliyor %d saniye sonra.\n", DEEP_SLEEP_TIME_SEC);
esp_sleep_enable_timer_wakeup(DEEP_SLEEP_TIME_SEC * 1000000);
esp_deep_sleep_start();

}
Serial.println("BME280 başarıyla başlatıldı.");

// Sensörden veri oku
float sicaklik = bme.readTemperature();
float nem = bme.readHumidity();
float basinç = bme.readPressure() / 100.0F; // hPa cinsinden

Serial.printf("Sıcaklık: %.2f °C\n", sicaklik);
Serial.printf("Nem: %.2f %%\n", nem);
Serial.printf("Basınç: %.2f hPa\n", basinç);

// Sensörün gücünü kes - KRİTİK ADIM!
digitalWrite(SENSOR_POWER_PIN, LOW);
delay(50); // Sensörün tamamen kapanması için

// Wi-Fi Bağlantısı
Serial.print("Wi-Fi bağlanılıyor...");
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, password);
int attempt = 0;
while (WiFi.status() != WL_CONNECTED && attempt < 20) {

delay(500);
Serial.print(".");
attempt++;

}

if (WiFi.status() == WL_CONNECTED) {

Serial.println("\nWi-Fi Bağlandı.");
Serial.print("IP Adresi: ");
Serial.println(WiFi.localIP());

// Burada verilerinizi bir sunucuya (MQTT/HTTP) gönderebilirsiniz
// Örnek olarak sadece seri portta gösteriyoruz.
Serial.println("Veriler başarıyla gönderildi (simülasyon).");

// Wi-Fi'yi kapat - KRİTİK ADIM!
WiFi.disconnect(true);
WiFi.mode(WIFI_OFF);
Serial.println("Wi-Fi kapatıldı.");

} else {

Serial.println("\nWi-Fi Bağlantı Hatası!");

}

// Deep Sleep'e geç
Serial.printf("Deep Sleep'e geçiliyor %d saniye sonra.\n", DEEP_SLEEP_TIME_SEC);
esp_sleep_enable_timer_wakeup(DEEP_SLEEP_TIME_SEC * 1000000); // mikrosaniye cinsinden
esp_deep_sleep_start();
}

void loop() {
// Bu kısım Deep Sleep kullandığımızda çalışmaz
}
`

3. Ölçüm ve Optimizasyon: Nereye Gidiyor Bu Enerji?

Projeyi kurduktan sonra multimetre ile akım ölçümü yapmak hayatidir! Seri olarak devreye bağlayacağınız bir multimetre ile:

• Aktif durumdaki tüketimi: Wi-Fi bağlıyken, sensör okurken ne kadar akım çekiyor?
• Uyku modundaki tüketimi: Deep Sleep'teyken kaç mikroamper çekiyor?

Bu ölçümler size darboğazı gösterecektir.
Eğer aktif akım çok yüksekse, Wi-Fi bağlantı süresini kısaltabilir veya daha az veri gönderebilirsiniz.
Eğer uyku akımı yüksekse, kart üzerindeki gereksiz LED'leri, USB-UART çipini kontrol edin. Çoğu geliştirme kartında USB-UART çipi Deep Sleep'teyken bile bir miktar akım çeker. Nihai üründe bu çipi ve onunla ilgili devreleri kaldırarak daha düşük bir uyku akımı elde edebilirsiniz.

Gerçek Bir Örnek: Haftalarca Çalışan BME280 Sensörü

Kendi deneyimlerimden yola çıkarak şunu rahatlıkla söyleyebilirim: Benim evimde 15 dakikada bir veri gönderen bir BME280 sensörü, bir ESP32 devkit kartı (üzerindeki güç LED'i devre dışı bırakılmış şekilde) ve 1200 mAh'lik standart bir LiPo pil ile 2 aydan daha uzun süre sorunsuz bir şekilde çalışabiliyor. Eğer kart üzerindeki gereksiz bileşenleri daha da optimize edebilirseniz (USB-UART çipi gibi), bu süreyi 3-4 aya kadar çıkarmak bile mümkün.

Buradaki en büyük fark, Wi-Fi'nin sadece veri gönderme anında açılıp, işi bittiğinde derhal kapatılması ve sensörün gücünün tamamen kesilmesidir.

Karşılaşılabilecek Zorluklar ve Çözümleri

• Wi-Fi Bağlantı Sorunları: Deep Sleep'ten uyanıp Wi-Fi'ye her seferinde yeniden bağlanmak zaman alabilir ve bazen başarısız olabilir. WiFi.begin() sonrası bir döngüde WiFi.status() kontrolü yaparak ve gerekirse belirli bir deneme sayısından sonra pes edip tekrar uykuya geçerek bu durumu yönetebilirsiniz.
• Pil Seviyesi İzleme: Pillerin bitmeye yakın olduğunu bilmek önemlidir. ESP32'nin ADC pinini kullanarak bir gerilim bölücü devresi aracılığıyla pil voltajını okuyabilir ve verilerinizle birlikte pil seviyesini de gönderebilirsiniz.
• OTA (Over-The-Air) Güncelleme: Deep Sleep projelerinde OTA güncelleme yapmak biraz daha karmaşık olabilir, çünkü cihaz çoğu zaman uyku modunda olacaktır. Bu durum için özel bir OTA stratejisi (örneğin, belirli zamanlarda daha uzun uyanık kalma veya bir düğmeye basılınca OTA moduna geçme) düşünmeniz gerekebilir.

Sonuç: Başarılı Bir Düşük Güç Tüketimli Sensör Sizin Elinizde!

Gördüğünüz gibi, ESP32 ile düşük güç tüketimli, haftalarca, hatta aylarca pil ömrü sunan akıllı ev sensörleri yapmak kesinlikle mümkün! İşin sırrı, ESP32'nin Deep Sleep modunu ve I2C sensörlerin güç kontrol yeteneğini akıllıca birleştirmekte yatıyor.

Bu rehberle kendi düşük güç tüketimli sensörlerinizi tasarlarken, biraz deney ve hata yapmaktan çekinmeyin. Akım ölçümleri yapın, kodunuzu optimize edin ve donanım seçimlerinizi gözden geçirin. Unutmayın, her proje biraz farklıdır ve en iyi sonuçlar genellikle kişisel denemelerle elde edilir.

Başarılar dilerim, akıllı eviniz ışıl ışıl ve sensörleriniz hep çalışır durumda kalsın!