Güneş Takip Sistemi Arduino: 4 LDR, Servo ve Verim Deneyi

Güneş takip sistemi, bir güneş panelini gün boyunca güneşe dönük tutan; ışığın geldiği yönü sensörlerle ölçüp paneli motorla çeviren otomatik bir düzenektir. Arduino ile yapılan güneş takip sistemi genellikle dört LDR (ışığa duyarlı direnç) ve iki servo motordan oluşur: LDR'ler hangi tarafın daha aydınlık olduğunu söyler, servolar da paneli o tarafa döndürür. Sabit bir panel sabah ve akşam saatlerinde güneşi yandan gördüğü için enerjinin önemli bir kısmını kaçırır; takip eden panel ise ışığı günün her saatinde dik açıya yakın yakalar.

Bu rehberde tek eksenli ve çift eksenli takip arasındaki farkı, 4 LDR ile ışık farkının nasıl hesaplandığını, servonun boşuna titremesini önleyen ölü bölge (tolerans) mantığını ve paneli taşıyan mekanik yapıyı adım adım öğreneceksin. Arduino Uno, ESP32 ve Raspberry Pi Pico için derlenmeye hazır kodların yanında, takip eden paneli sabit bir panelle karşılaştırıp enerji kazancını gerçekten ölçen bir deney düzeneği, malzeme listesi ve TÜBİTAK sunumu için ipuçları da bu yazıda.

Güneş takip sistemi nedir, verimi neden artırır?

Bir panelin ürettiği güç, ışığın panel yüzeyine geliş açısına bağlıdır. Işık yüzeye tam dik geldiğinde panel en fazla ışığı yakalar; ışık eğik geldikçe aynı ışık demeti daha geniş bir alana yayılır ve panelin gördüğü ışık şiddeti gelme açısının kosinüsü oranında azalır. Bu yüzden dik doğrultudan 60° sapmış ışık, panele dik gelen ışığın yalnızca yarısı kadar güç üretir. Aşağıdaki tablo bu kaybı gösterir. Tabloya dikkatli bakarsan küçük hataların neredeyse hiç kayıp yaratmadığını da görürsün: güneşi 5° kaçıran bir panel gücünün yalnızca %0,4'ünü kaybeder. Bu bilgi, ileride ölü bölgeyi seçerken işine yarayacak.

Güneşin gökyüzündeki yeri iki açıyla tarif edilir: yön açısı (azimut), yani ufukta hangi yönde olduğu, ve yükseklik açısı, yani ufkun ne kadar üstünde olduğu. Dünya saatte 15° döndüğü için güneş gökyüzünde ortalama 4 dakikada yaklaşık 1° yer değiştirir; yükseklik ise mevsime göre büyük farklar gösterir. Türkiye'nin ortası için (yaklaşık 39° kuzey enlemi) değerler şöyledir:

Yön açıları kuzeyden saat yönünde ölçülür. Tablodan iki önemli sonuç çıkar. Yazın güneş kuzeydoğudan doğup kuzeybatıdan battığı için gün içinde yaklaşık 240° yol alır; 180° dönebilen bir servo sabahın ilk ve akşamın son saatlerinde güneşe tam dönemez, ama o saatlerde güneş alçakta ve zayıf olduğu için kayıp küçüktür. Kışın ise güneş öğlende bile alçakta kalır, bu yüzden güneye bakan sabit bir panelin eğimini mevsime göre değiştirmek gerekir. Takip sistemi bu iki sorunu da kendiliğinden çözer.

Tek eksen mi, çift eksen mi?

Tek eksenli sistem yalnızca güneşin doğudan batıya hareketini izler; eğimi sabittir ve mevsime uygun bir açıda bırakılır. Kazancın büyük kısmını bu eksen sağlar, çünkü güneşin gün içindeki en büyük yer değiştirmesi doğu–batı yönündedir. Büyük güneş santrallerinde de en yaygın tür tek eksenli takiptir; çift eksenli sistemler biraz daha fazla enerji toplasa da daha pahalıdır ve daha çok bakım ister. Okul projesinde ise çift eksen hem daha etkileyici bir gösteri hem de iki ekseni birlikte kontrol etmeyi öğreten güzel bir problemdir.

Işık farkını ölçmek: 4 LDR ve gölge duvarı

LDR'yi tek başına kullanırsan yalnızca ortamın ne kadar aydınlık olduğunu öğrenirsin; yönü bulmak için en az iki LDR'yi karşılaştırman gerekir. Çift eksenli sistemde dört LDR 2×2 bir kare oluşturacak şekilde yerleştirilir ve aralarına artı (+) biçiminde ışık geçirmeyen bir perde, yani gölge duvarı konur. Sensör güneşe tam dönükken duvarın gölgesi hiçbir LDR'ye düşmez ve dördü de aynı ışığı görür. Güneş bir yana kaydığında duvar karşı taraftaki LDR'lerin üzerine gölge düşürür ve onların değeri düşer. Duvarın yüksekliği hassasiyeti belirler: 3 cm yüksekliğindeki bir duvar 5° sapmada yaklaşık 2,6 mm genişliğinde gölge düşürür (3 cm × tan 5°); bu da 5 mm çaplı bir LDR'nin yarısını kapatmaya yeter. Yüksek duvar daha hassas ama daha dar açılı, alçak duvar daha kaba ama daha geniş açılı bir sensör demektir. LDR'nin nasıl çalıştığını ayrıntılı görmek için LDR Işık Sensörü yazısına bakabilirsin.

• Üst ortalama: (sol üst + sağ üst) / 2
• Alt ortalama: (sol alt + sağ alt) / 2
• Sol ortalama: (sol üst + sol alt) / 2
• Sağ ortalama: (sağ üst + sağ alt) / 2
• Dikey fark (dV): üst − alt. Pozitifse panel yukarı, negatifse aşağı eğilmelidir.
• Yatay fark (dH): sol − sağ. Pozitifse panel sola, negatifse sağa dönmelidir.

Sensörle mi, saatle mi takip?

LDR ile takip tek yöntem değildir. Güneşin konumu tarih, saat ve coğrafi konuma göre önceden hesaplanabildiği için bazı sistemler hiç ışık sensörü kullanmaz. Üç yaklaşımı karşılaştıralım:

Bu rehberde sensörlü yöntemi kuruyoruz, çünkü konum ve saat bilgisi istemez, kurulumu basittir ve mekanik hataları kendiliğinden düzeltir. Projeni geliştirmek istersen ileride bir RTC modülüyle saat tabanlı takibi ekleyip iki yöntemi karşılaştırmak, jüri önünde çok güçlü bir ek deney olur.

Malzeme listesi

Bağlantı şeması: Arduino Uno, ESP32 ve Pico

Her LDR'nin bir bacağı beslemeye (Uno'da 5V, ESP32 ve Pico'da 3V3), diğer bacağı analog pine bağlanır; aynı analog pinden GND'ye bir sabit direnç gider. Böylece ışık arttıkça okunan değer de artar. Panel tarafında her panelin iki ucu arasına bir yük direnci (33 Ω) bağlanır. Panelin gerilimi 22 kΩ ve 10 kΩ'luk bir bölücüyle 3,2'ye bölünerek analog pine verilir: 22 kΩ panelin artı ucundan analog pine, 10 kΩ analog pinden GND'ye. Panelin eksi ucu da kartın GND'sine bağlanmalıdır; ortak toprak olmadan ölçüm anlamsızdır.

Mekanik yapı: pan-tilt düzeneği ve panel dengesi

En kolay mekanik çözüm, iki SG90 servoyu üst üste taşıyan hazır bir pan-tilt braketidir: alttaki servo paneli yatayda (doğu–batı), üstteki servo dikeyde (eğim) çevirir. Sensör bloğunu panelin kenarına, yüzeyi panel yüzeyiyle tam paralel olacak şekilde yapıştır. Sensör panelden farklı bir yöne bakarsa sistem güneşi kusursuz izler ama panel hep birkaç derece yanına bakar. 110×60 mm'lik 6 V 1 W bir mini panel yaklaşık 22 g gelir; bu ağırlık 3 cm uzaktan yaklaşık 0,07 kg·cm tork demektir ve SG90'ın 1,8 kg·cm'lik torkunun çok altındadır. Asıl yük rüzgârdır: dışarıda deney yapacaksan paneli servo eksenine ortala, metal dişli MG90S kullan, daha büyük panellerde MG996R gibi güçlü bir servoya geç. Kablolara dönüş için gevşek bir halka bırak; gergin kablo servoyu zorlar ve bağlantıları koparır. Servo temelleri için Servo Motor Nedir? yazısına bakabilirsin.

Adım adım kurulum

1. Dört LDR'yi bir delikli plaket parçasına 2×2 kare biçiminde lehimle, aralarına 2–3 cm yüksekliğinde artı şeklinde bir karton ya da 3D baskı perde yapıştır; perdeyi mat siyaha boya ya da siyah bantla kapla.
2. Her LDR için bölücüyü kur: LDR beslemeden analog pine, sabit direnç analog pinden GND'ye.
3. Servoları pan-tilt braketine tak, ikisini de 90°'ye getir ve kollarını (horn) orta konumda olacak şekilde vidala.
4. Paneli ve sensör bloğunu üstteki braketin üzerine, yüzeyleri paralel olacak şekilde sabitle.
5. Panel ölçüm devresini kur: yük direnci panelin iki ucuna, bölücü panelin artı ucu ile GND arasına, orta nokta A4'e.
6. Servoları harici 5 V kaynaktan besle, bütün GND'leri birleştir ve 470 µF kondansatörü servo beslemesine paralel bağla.
7. Önce kalibrasyon kodunu, sonra takip kodunu yükle ve sistemi bir el feneriyle test et.

Adım 1: LDR'leri test et ve kalibre et

Aynı paketten çıkan LDR'ler bile aynı ışıkta belirgin biçimde farklı değerler verir; GL5528'in veri sayfası 10 lux'ta 10–20 kΩ gibi geniş bir aralık tanımlar. Kalibre edilmemiş bir sensör güneşe tam dönükken bile bir tarafı daha aydınlık sanır ve paneli birkaç derece yanlış yöne çevirir. Aşağıdaki kodu yükle, Araçlar menüsünden Seri Çizici'yi (Serial Plotter) aç ve sensör bloğunu eşit bir ışıkla aydınlat; örneğin lambanın önüne bir A4 kâğıdı germek ışığı dağıtıp eşitler.

1// 4 LDR'yi okuyup Seri Çizici'ye yazar / reads 4 LDRs for the Serial Plotter
2const int LDR[4] = {A0, A1, A2, A3};   // sol üst, sağ üst, sol alt, sağ alt / TL, TR, BL, BR
3
4void setup() {
5  Serial.begin(9600);
6}
7
8void loop() {
9  for (int i = 0; i < 4; i++) {
10    Serial.print(analogRead(LDR[i]));
11    Serial.print(i < 3 ? '\t' : '\n');  // sekmeyle ayır / separate with tabs
12  }
13  delay(100);
14}

Dört çizgi aynı ışıkta aynı seviyede olmalıdır. Diyelim ki değerler 612, 640, 598 ve 625 çıktı; ortalama 619'dur. Her LDR'nin düzeltmesi, ortalama eksi kendi değeridir: +7, −21, +21 ve −6. Bu sayıları Adım 3'teki kodda OFFSET dizisine yazarsın. LDR'nin direnci ışıkla doğrusal değişmediği için kalibrasyonu, sistemin gerçekten çalışacağı ışık seviyesine yakın bir ışıkta yapmak en doğru sonucu verir. Seri Çizici'de gürültüyü de görürsün: hiçbir şeye dokunmadığın hâlde değerlerin kaç birim oynadığını not et, ölü bölgeyi seçerken bu sayıya ihtiyacın olacak.

Adım 2: Tek eksenli güneş takip kodu

Önce mantığı tek eksende görelim. İki LDR, aralarındaki dikey bir gölge duvarıyla doğu ve batı tarafına bakar: A0 doğu, A1 batı LDR'sidir. Kod iki değeri birbirinden çıkarır; fark ölü bölgeden büyükse servo aydınlık tarafa 1° döner, küçükse yerinde kalır. Bu 20 satırlık kod, tek eksenli bir sistemin tamamıdır. Panel ışıktan kaçıyorsa iki koşuldaki angle++ ve angle-- ifadelerinin yerini değiştir.

1#include <Servo.h>
2
3Servo servo;
4const int LDR_EAST = A0;   // doğu tarafındaki LDR / east-side LDR
5const int LDR_WEST = A1;   // batı tarafındaki LDR / west-side LDR
6const int TOL = 30;        // ölü bölge (ADC birimi) / dead band (ADC counts)
7int angle = 90;            // başlangıç: tam güney / start: due south
8
9void setup() {
10  servo.attach(9);
11  servo.write(angle);
12}
13
14void loop() {
15  int diff = analogRead(LDR_EAST) - analogRead(LDR_WEST);
16  if (diff > TOL && angle < 180) angle++;   // doğu daha aydınlık / east is brighter
17  if (diff < -TOL && angle > 0) angle--;    // batı daha aydınlık / west is brighter
18  servo.write(angle);
19  delay(30);                                // servo yetişsin / let the servo settle
20}

delay(30) ile servo her 30 ms'de en fazla 1° döner; bu da saniyede yaklaşık 33° demektir ve el feneriyle yapılan gösteride panel ışığı rahatça izler. Güneş ise çok daha yavaş hareket ettiği için gerçek kullanımda düzeltmeyi birkaç saniyede bir yapmak yeterlidir.

Adım 3: Çift eksenli kod, ölü bölge ve veri kaydı

Tam sürüm dört LDR'den iki fark hesaplar, her ekseni ayrı ayrı düzeltir, gece olunca paneli sabaha hazır bekletir ve dakikada bir, iki panelin gerilimini, gücünü ve toplanan enerjiyi CSV biçiminde Seri Monitör'e yazar. Kod delay() yerine millis() kullanır; böylece takip ve kayıt birbirini beklemeden çalışır. Bu yöntemin ayrıntısı millis ve delay yazısında.

1#include <Servo.h>
2
3// Pinler / Pins
4const int LDR[4] = {A0, A1, A2, A3};   // sol üst, sağ üst, sol alt, sağ alt / TL, TR, BL, BR
5const int PANEL_TRACK = A4;            // takip eden panelin bölücüsü / tracking panel divider
6const int PANEL_FIXED = A5;            // sabit panelin bölücüsü / fixed panel divider
7
8// Ayarlar / Settings
9const int OFFSET[4] = {0, 0, 0, 0};    // Adım 1'deki düzeltmeler / corrections from step 1
10const int TOL_START = 40;              // fark bunu aşınca dön / start turning above this
11const int TOL_STOP = 15;               // fark bunun altına inince dur / stop below this
12const int DIR_H = 1, DIR_V = 1;        // ters dönüyorsa -1 yap / set to -1 if it turns away
13const int H_MIN = 0, H_MAX = 180;      // yatay sınırlar / horizontal limits
14const int V_MIN = 10, V_MAX = 90;      // dikey sınırlar / vertical limits
15const int H_PARK = 180, V_PARK = 45;   // gece konumu: doğu (batıda bekliyorsa H_PARK = 0) / night position: east (0 if it waits facing west)
16const int NIGHT = 60;                  // ortalama bunun altındaysa gece / below this average = night
17const float DIVIDER = 3.2;             // (22k + 10k) / 10k
18const float LOAD_OHM = 33.0;           // yük direnci / load resistor
19const unsigned long LOG_MS = 60000;    // kayıt aralığı: 1 dk / log interval: 1 min
20
21Servo servoH, servoV;                  // yatay ve dikey eksen / horizontal and vertical axis
22int angleH = 90, angleV = 45;
23bool movingH = false, movingV = false;
24unsigned long lastStep = 0, lastLog = 0, darkSince = 0;
25float mWhTrack = 0, mWhFixed = 0;      // toplanan enerji / collected energy
26
27int readAvg(int pin) {                 // 8 okumanın ortalaması / average of 8 readings
28  long sum = 0;
29  for (int i = 0; i < 8; i++) sum += analogRead(pin);
30  return sum / 8;
31}
32
33// Ölü bölge + histerezis / dead band + hysteresis
34int correct(int diff, bool &moving, int angle, int dir, int lo, int hi) {
35  if (abs(diff) > TOL_START) moving = true;
36  if (abs(diff) < TOL_STOP) moving = false;
37  if (moving) angle += (diff > 0 ? 1 : -1) * dir;
38  return constrain(angle, lo, hi);
39}
40
41float panelVolts(int pin) {            // bölücüden panel gerilimi / panel voltage from divider
42  return readAvg(pin) * 5.0 / 1023.0 * DIVIDER;
43}
44
45void setup() {
46  Serial.begin(9600);
47  servoH.attach(9);
48  servoV.attach(10);
49  servoH.write(angleH);
50  servoV.write(angleV);
51  Serial.println("dk,V_takip,V_sabit,mW_takip,mW_sabit,mWh_takip,mWh_sabit");
52}
53
54void loop() {
55  unsigned long now = millis();
56
57  if (now - lastStep >= 40) {          // saniyede 25 düzeltme / 25 corrections per second
58    lastStep = now;
59    int v[4];
60    for (int i = 0; i < 4; i++) v[i] = readAvg(LDR[i]) + OFFSET[i];
61    int avg = (v[0] + v[1] + v[2] + v[3]) / 4;
62    int dV = (v[0] + v[1]) / 2 - (v[2] + v[3]) / 2;   // üst - alt / top - bottom
63    int dH = (v[0] + v[2]) / 2 - (v[1] + v[3]) / 2;   // sol - sağ / left - right
64
65    if (avg > NIGHT) {
66      darkSince = now;
67      angleV = correct(dV, movingV, angleV, DIR_V, V_MIN, V_MAX);
68      angleH = correct(dH, movingH, angleH, DIR_H, H_MIN, H_MAX);
69    } else if (now - darkSince > 600000UL) {           // 10 dk karanlık / 10 min of darkness
70      angleH = H_PARK;
71      angleV = V_PARK;
72    }
73    servoH.write(angleH);
74    servoV.write(angleV);
75  }
76
77  if (now - lastLog >= LOG_MS) {       // dakikada bir CSV satırı / one CSV line per minute
78    lastLog = now;
79    float vt = panelVolts(PANEL_TRACK), vf = panelVolts(PANEL_FIXED);
80    float pt = vt * vt / LOAD_OHM * 1000.0;    // P = V² / R (mW)
81    float pf = vf * vf / LOAD_OHM * 1000.0;
82    mWhTrack += pt * LOG_MS / 3600000.0;       // enerji = güç × süre / energy = power × time
83    mWhFixed += pf * LOG_MS / 3600000.0;
84    Serial.print(now / 60000); Serial.print(',');
85    Serial.print(vt, 2); Serial.print(',');
86    Serial.print(vf, 2); Serial.print(',');
87    Serial.print(pt, 1); Serial.print(',');
88    Serial.print(pf, 1); Serial.print(',');
89    Serial.print(mWhTrack, 1); Serial.print(',');
90    Serial.println(mWhFixed, 1);
91  }
92}

Ölü bölge (tolerans) ile titreşimi önlemek

Ölü bölge olmadan sistem hiç durmaz. Güneşe tam dönükken bile LDR değerleri gürültü yüzünden birkaç birim oynar, fark bir artı bir eksi olur ve servo sürekli 1° sağa, 1° sola gider. Bu titreşim hem servonun dişlilerini aşındırır hem de boşuna enerji harcar. Çözüm, farkın küçük değerlerini görmezden gelmektir: fark belirli bir sınırın altındaysa hiçbir şey yapılmaz. Sınırı seçerken kalibrasyonda gördüğün gürültüyü kullan ve ölü bölgeyi gürültünün en az 3–4 katı seç. Uno'da gürültü ±5 birim civarındaysa 20–40 iyi bir başlangıçtır.

Koddaki yöntem bunun bir adım ötesidir: histerezis. Servo, fark 40'ı aşınca harekete başlar ama fark 15'in altına inene kadar durmaz. Tek sınırlı ölü bölgede panel sınırın hemen kenarında durur ve küçük bir bulut ya da rüzgâr onu yeniden harekete geçirir; iki sınırlı sistem ise her seferinde paneli güneşe iyice yaklaştırıp sonra sakinleşir. Ölü bölgenin enerji kaybına etkisi de ihmal edilebilir: kosinüs tablosunda gördüğün gibi birkaç derecelik sapma %1'in altında kayıp demektir. Daha fazla filtreleme yöntemi için sensör verisi filtreleme yazısına bakabilirsin.

Verim deneyi: takip eden panel ile sabit panel

Takip sisteminin işe yaradığını kanıtlamanın tek yolu ölçmektir. Burada sık yapılan hata, panelin yalnızca açık devre gerilimini ölçmektir. Panelin yüksüz gerilimi ışıkla çok az değişir: ışık yarıya indiğinde akım da yaklaşık yarıya iner, ama açık devre gerilimi yalnızca %3–5 düşer. Bu yüzden iki panel de 7 V civarında görünür ve fark kaybolur. Doğru yöntem, her panele aynı yük direncini bağlayıp direnç üzerindeki gerilimi ölçmektir. Güç P = V² / R ile, enerji de gücün zamanla toplanmasıyla bulunur. Yük direncini panelin en yüksek güç noktasına göre seç: 6 V 1 W bir panelde akım yaklaşık 1 / 6 = 0,17 A, uygun direnç de 6 / 0,17 ≈ 36 Ω olur; standart 33 Ω iyi bir seçimdir. Direnç 1 W'a yakın ısı ürettiği için en az 2 W, tercihen 5 W'lık taş direnç kullan. Hesap için Ohm kanunu aracını kullanabilirsin.

1. İki özdeş panel kullan: aynı model, mümkünse aynı paketten. İkisine de 33 Ω yük direnci ve 22 kΩ / 10 kΩ bölücü bağla; takip eden paneli A4'e, sabit paneli A5'e ver.
2. Ön test yap: iki paneli yan yana, aynı yöne ve eğime sabitleyip 30–60 dakika ölç. Aradaki farkı (örneğin %2) not et ve sonuçlarını bu farka göre düzelt. Daha da iyisi, ikinci gün panellerin yerini değiştir.
3. Sabit paneli tam güneye çevir ve eğimini o günün öğlen güneşine göre ayarla (aşağıdaki uyarıya bak).
4. İki paneli birbirine ve sensöre gölge düşürmeyecek kadar uzağa, ağaç ya da duvar gölgesi olmayan bir yere koy.
5. Multimetreyle bir kez panel gerilimini ölçüp Arduino'nun okumasıyla karşılaştır; fark varsa DIVIDER değerini düzelt (multimetre nasıl kullanılır).
6. Kaydı gün doğumundan gün batımına kadar dakikada bir al ve hava durumunu (açık, parçalı bulutlu, kapalı) not et.
7. Deneyi en az üç açık günde tekrarla, kapalı bir günü ayrıca kaydet ve günlük enerjilerin ortalamasını karşılaştır.

Verileri Seri Monitör'den kopyalayıp CSV dosyası olarak kaydedebilir ya da doğrudan Excel'e aktarabilirsin (Arduino'dan Excel'e veri aktarma); bilgisayar başında beklemek istemiyorsan bir SD kart modülü ekle. Açık bir günün grafiğinde sabah ve akşam saatlerinde takip eden panelin çizgisi belirgin biçimde yukarıda kalır, öğle saatlerinde ise iki çizgi neredeyse üst üste biner. Büyük sistemler için tek eksenli takipte yaklaşık %15–35, çift eksenli takipte %30–45 enerji artışı bildirilir; mini bir düzenekte sonuç havaya, mevsime ve sabit panelin ne kadar iyi yönlendirildiğine çok bağlıdır. Ölçtüğün şeyin panelin kendi verimi değil, aynı panelin topladığı enerjideki artış olduğunu raporunda açıkça yaz. Bir sınırlılığı da ekle: sabit bir yük direncinde güç akımın karesiyle değiştiği için ışık zayıfladıkça panelin gücü ışıktan daha hızlı düşer; bu yüzden ölçtüğün yüzde kazanç, şarj devresine bağlı gerçek bir sistemdekinden yüksek çıkabilir. İki panelin akımlarını (V / R) da toplayıp karşılaştırırsan panellere düşen ışıktaki gerçek farkı da görürsün.

Enerji bütçesi: sistem kendi enerjisini karşılar mı?

Jürinin en sevdiği soru budur. Takip sistemi enerji kazandırır, ama kendisi de enerji harcar. Mini bir maket için yaklaşık hesap şöyle:

Tablo açıkça gösteriyor: mini bir maket kendi elektroniğini çalıştıracak kadar enerji üretemez. Takipten gelen yaklaşık 1–1,5 Wh'lik ek enerji, Uno'nun günde harcadığı 6 Wh'in yanında küçük kalır. Bu bir başarısızlık değil, dürüst ve değerli bir sonuçtur. Ölçek büyüdükçe tablo tersine döner: kilovatlık panelleri çeviren motorun ve denetleyicinin tüketimi üretimin küçük bir oranına iner. Mini sistemde tüketimi azaltmak istersen düzeltmeyi dakikada bir yap, servoları hareket etmezken detach() ile serbest bırak, Uno yerine uyku moduna giren bir Pro Mini ya da deep sleep kullanan bir ESP32 tercih et. Pille çalışma süresini hesaplamak için Pil ömrü aracını ve mAh ve Wh yazısını kullanabilirsin.

ESP32 ile güneş takip ve telefondan izleme

ESP32 aynı mantığı daha hassas bir ADC ve Wi-Fi ile çalıştırır. Dikkat etmen gereken birkaç fark var. Analog okumalar 0–4095 aralığındadır, bu yüzden ölü bölge Uno'nun yaklaşık 4 katıdır. Wi-Fi açıkken yalnızca ADC1 pinleri (GPIO 32–39) güvenilir çalışır, çünkü ADC2 pinleri Wi-Fi tarafından kullanılır. Servo için Kütüphane Yöneticisi'nden ESP32Servo kütüphanesini kur. Panel gerilimini ölçerken kullanılan analogReadMilliVolts() fonksiyonu, ESP32 ADC'sinin doğrusal olmayan davranışını fabrika kalibrasyonuyla düzeltir. LDR bölücülerini mutlaka 3V3'ten besle. Kod yüklendikten sonra Seri Monitör'de görünen IP adresini aynı ağa bağlı telefonunda açarsan iki panelin anlık gerilimini, toplanan enerjiyi ve kazancı görürsün. ESP32'ye yeni başlıyorsan ESP32 Nedir? yazısıyla başla.

1#include <WiFi.h>
2#include <WebServer.h>
3#include <ESP32Servo.h>
4
5const char* ssid = "AgAdi";            // Wi-Fi adın / your Wi-Fi name
6const char* password = "Sifre123";     // Wi-Fi şifren / your Wi-Fi password
7
8const int LDR[4] = {32, 33, 34, 35};   // sol üst, sağ üst, sol alt, sağ alt (ADC1) / TL, TR, BL, BR (ADC1)
9const int PANEL_TRACK = 36;            // VP: takip eden panel / tracking panel
10const int PANEL_FIXED = 39;            // VN: sabit panel / fixed panel
11const int TOL_START = 160, TOL_STOP = 60;  // 12 bit ölçek: Uno'nun 4 katı / 12-bit scale: 4x the Uno
12const int DIR_H = 1, DIR_V = 1;        // ters dönüyorsa -1 yap / set to -1 if it turns away
13const int NIGHT = 240;                 // gece eşiği / night threshold
14const float DIVIDER = 3.2, LOAD_OHM = 33.0;
15
16Servo servoH, servoV;
17WebServer server(80);
18int angleH = 90, angleV = 45;
19bool movingH = false, movingV = false;
20unsigned long lastStep = 0, lastLog = 0;
21float vt = 0, vf = 0, mWhTrack = 0, mWhFixed = 0;
22
23int readAvg(int pin) {
24  long sum = 0;
25  for (int i = 0; i < 8; i++) sum += analogRead(pin);
26  return sum / 8;
27}
28
29float panelVolts(int pin) {            // kalibre edilmiş mV okuması / calibrated mV reading
30  long mv = 0;
31  for (int i = 0; i < 8; i++) mv += analogReadMilliVolts(pin);
32  return mv / 8 / 1000.0 * DIVIDER;
33}
34
35int correct(int diff, bool &moving, int angle, int dir, int lo, int hi) {
36  if (abs(diff) > TOL_START) moving = true;
37  if (abs(diff) < TOL_STOP) moving = false;
38  if (moving) angle += (diff > 0 ? 1 : -1) * dir;
39  return constrain(angle, lo, hi);
40}
41
42void handleRoot() {                    // telefondan izleme sayfası / page for your phone
43  float gain = mWhFixed > 0 ? (mWhTrack - mWhFixed) / mWhFixed * 100.0 : 0;
44  String s = "Takip / tracking: " + String(vt, 2) + " V, " + String(mWhTrack, 1) + " mWh\n";
45  s += "Sabit / fixed: " + String(vf, 2) + " V, " + String(mWhFixed, 1) + " mWh\n";
46  s += "Kazanc / gain: %" + String(gain, 1) + "\n";
47  s += "Aci / angle: H " + String(angleH) + ", V " + String(angleV) + "\n";
48  server.send(200, "text/plain", s);
49}
50
51void setup() {
52  Serial.begin(115200);
53  servoH.setPeriodHertz(50);           // standart servo: 50 Hz / standard servo: 50 Hz
54  servoV.setPeriodHertz(50);
55  servoH.attach(18, 500, 2400);        // 500–2400 µs darbe / pulse
56  servoV.attach(19, 500, 2400);
57  servoH.write(angleH);
58  servoV.write(angleV);
59  WiFi.begin(ssid, password);
60  for (int i = 0; i < 40 && WiFi.status() != WL_CONNECTED; i++) delay(500);  // en fazla 20 s bekle; Wi-Fi yoksa da takip eder / wait up to 20 s; tracks even without Wi-Fi
61  Serial.println(WiFi.localIP());      // bu adresi telefonda aç / open this address on your phone
62  server.on("/", handleRoot);
63  server.begin();
64}
65
66void loop() {
67  server.handleClient();
68  unsigned long now = millis();
69
70  if (now - lastStep >= 40) {
71    lastStep = now;
72    int v[4];
73    for (int i = 0; i < 4; i++) v[i] = readAvg(LDR[i]);
74    int avg = (v[0] + v[1] + v[2] + v[3]) / 4;
75    int dV = (v[0] + v[1]) / 2 - (v[2] + v[3]) / 2;   // üst - alt / top - bottom
76    int dH = (v[0] + v[2]) / 2 - (v[1] + v[3]) / 2;   // sol - sağ / left - right
77    if (avg > NIGHT) {                 // gece hareket etme / do not move at night
78      angleV = correct(dV, movingV, angleV, DIR_V, 10, 90);
79      angleH = correct(dH, movingH, angleH, DIR_H, 0, 180);
80      servoV.write(angleV);
81      servoH.write(angleH);
82    }
83  }
84
85  if (now - lastLog >= 60000) {        // dakikada bir ölç / measure once a minute
86    lastLog = now;
87    vt = panelVolts(PANEL_TRACK);
88    vf = panelVolts(PANEL_FIXED);
89    mWhTrack += vt * vt / LOAD_OHM * 1000.0 / 60.0;   // 1 dakikalık enerji (mWh) / energy of one minute
90    mWhFixed += vf * vf / LOAD_OHM * 1000.0 / 60.0;
91    Serial.printf("%.2f,%.2f,%.1f,%.1f\n", vt, vf, mWhTrack, mWhFixed);
92  }
93}

Ölçümleri günlerce saklamak istersen aynı değerleri internet üzerinden bir tabloya gönderebilirsin; bunun için ESP32 ile Google E-Tablolar'a veri kaydı yazısına bakabilirsin. ADC çözünürlüğü ve referans gerilimi hakkında daha fazlası ADC ve analog-dijital dönüşüm yazısında.

Raspberry Pi Pico ve MicroPython ile tek eksenli takip

Pico'da dışarıya açık yalnızca üç analog giriş (GP26, GP27, GP28) vardır; dört LDR ve iki panel için yetmez. Bu yüzden Pico ile en temiz çözüm tek eksenli sistemdir: iki LDR yönü bulur, üçüncü analog giriş panel gerilimini ölçer. Çift eksen istersen I2C ile çalışan 4 kanallı ADS1115 gibi harici bir ADC ekleyebilirsin. Servo 50 Hz PWM ile doğrudan sürülür: 500 µs'lik darbe 0°, 2400 µs'lik darbe 180° demektir. read_u16() değeri 0–65535 ölçeğinde olduğu için ölü bölge 2000 gibi büyük bir sayıdır. Pico'ya MicroPython kurmayı Raspberry Pi Pico Nedir? yazısında bulabilirsin.

1from machine import Pin, PWM, ADC
2import time
3
4east = ADC(26)                 # GP26: doğu LDR'si / east LDR
5west = ADC(27)                 # GP27: batı LDR'si / west LDR
6panel = ADC(28)                # GP28: panel bölücüsü / panel divider
7
8servo = PWM(Pin(15))           # GP15: servo sinyali / servo signal
9servo.freq(50)                 # 50 Hz = 20 ms periyot / period
10
11TOL = 2000                     # ölü bölge (0–65535 ölçeği) / dead band (0–65535 scale)
12DIVIDER = 3.2                  # (22k + 10k) / 10k
13LOAD = 33.0                    # yük direnci (ohm) / load resistor (ohm)
14
15def set_angle(a):
16    # 0° = 500 µs, 180° = 2400 µs darbe / pulse
17    servo.duty_ns(int((500 + a * 1900 / 180) * 1000))
18
19def read(adc, n=8):
20    return sum(adc.read_u16() for _ in range(n)) // n
21
22angle = 90
23set_angle(angle)
24energy = 0.0                   # mWh
25last_log = time.ticks_ms()
26
27while True:
28    diff = read(east) - read(west)
29    if diff > TOL and angle < 180:
30        angle += 1             # doğuya dön / turn east
31    elif diff < -TOL and angle > 0:
32        angle -= 1             # batıya dön / turn west
33    set_angle(angle)
34
35    if time.ticks_diff(time.ticks_ms(), last_log) >= 60000:
36        last_log = time.ticks_ms()
37        v = read(panel) * 3.3 / 65535 * DIVIDER
38        p = v * v / LOAD * 1000            # mW
39        energy += p / 60                   # 1 dakikalık enerji / energy of one minute
40        with open("log.csv", "a") as f:    # Pico'nun kendi belleğine yaz / write to Pico's flash
41            f.write("{},{:.2f},{:.1f},{:.1f}\n".format(angle, v, p, energy))
42    time.sleep_ms(30)

Kod ölçümleri Pico'nun kendi belleğindeki log.csv dosyasına ekler. Dakikada bir satır, bir günde 30–40 KB eder; Pico'nun yaklaşık 1,4 MB'lık dosya alanı haftalarca yeter. Dosyayı main.py adıyla kaydedersen Pico bilgisayara bağlı olmadan, bir pil ya da USB adaptörüyle beslendiği anda kendiliğinden çalışır. Günün sonunda Thonny ile log.csv dosyasını bilgisayarına indirip Excel'de açabilirsin.

TÜBİTAK sunumu için ipuçları

Güneş takip sistemi TÜBİTAK 4006 ve 2204 sergilerinde sık görülen bir projedir; seni öne çıkaracak şey maketin kendisi değil, ölçülmüş verin ve bu veriyi nasıl yorumladığındır. Proje fikirleri ve rapor yapısı için TÜBİTAK Arduino proje fikirleri yazısına da göz at.

• Ölçülebilir bir soru sor: Çift eksenli takip, güneye en iyi açıyla sabitlenmiş özdeş bir panele göre açık bir sonbahar gününde yüzde kaç daha fazla enerji toplar?
• Hipotezini önceden yaz: Örneğin kazancın sabah ve akşam saatlerinde yoğunlaşacağını öngör; sonuç hipotezini doğrulamasa bile bunu tartışmak puan kazandırır.
• Değişkenleri ayır: Bağımsız değişken takip yöntemi (yok, tek eksen, çift eksen), bağımlı değişken günlük enerji (Wh), kontrol değişkenleri panel modeli, yük direnci, konum ve tarihtir.
• Grafikle anlat: Saat–güç çizgi grafiği iki paneli üst üste gösterir; günlük enerjileri sütun grafikle karşılaştır ve günler arasındaki farkı hata payı olarak belirt.
• Net enerjiyi tartış: Sistemin kendi tüketimini ölç ve enerji bütçesi tablosunu posterine koy; bu, projenin dürüst ve bilimsel olduğunu gösterir.
• Sergi salonunda güneş yok: Canlı gösteriyi el feneri ya da spot lambayla yap; dışarıdaki deneyin hızlandırılmış videosunu ve ham CSV dosyasını yanında bulundur.
• Posteri düzenle: Problem, yöntem, devre şeması, kodun akış şeması, sonuçlar, sınırlılıklar ve öneriler; her bölümde kısa cümleler ve büyük grafikler.
• Sınırlılıkları sen söyle: Mini panel, birkaç günlük veri, rüzgâr ve LDR farkları gibi sınırları jüri sormadan belirtmek güven verir.

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

Projeyi geliştirmek için fikirler

• Güneşle şarj olan pil istasyonu: Takip eden paneli bir TP4056 şarj modülü ve 18650 pile bağla, pilin dolma süresini sabit panelle karşılaştır.
• Hibrit takip: Bir RTC saat modülü ile güneşin konumunu hesapla, LDR'lerle yalnızca ince ayar yap; bulutlu havada bile panel doğru yöne bakar.
• Wi-Fi veri kaydı: ESP32 ile ölçümleri Google E-Tablolar'a gönder, grafiği telefondan canlı izle.
• Güneş enerjili sera: Takipli paneli bir akıllı sera maketinin fanını ve sulamasını beslemek için kullan.
• Işık tarayıcı: Tek bir LDR'yi servoyla 0–180° tarayıp en parlak yönü bulan bir sürüm yap; mantık Arduino radar projesine çok benzer.
• Daha hassas güç ölçümü: Yük direncinin yanında akımı ve gerilimi birlikte ölçen INA219 gibi bir I2C güç sensörü kullan ve panelin güç eğrisini çiz.

Güneş takip sistemi; sensör okumayı, karar vermeyi, motor kontrolünü ve bilimsel ölçümü tek projede birleştirdiği için hem öğrenmek hem de yarışmada göstermek için harika bir seçimdir. Önce tek eksenle başla, ölü bölgeyi ayarla, sonra ikinci ekseni ve sabit panelli deneyi ekle. BlueGrays uygulamasında LDR ile ışık ölçme, gece lambası, servo açı kontrolü ve dijital voltmetre gibi bu sistemin her parçasını ayrı ayrı deneyebileceğin projeleri devre şemaları ve kodlarıyla bulabilirsin.