Pelacak Matahari Arduino: Rakitan Dua Sumbu dengan 4 LDR dan Servo

Pelacak matahari Arduino (solar tracker) adalah mekanisme otomatis yang membuat panel surya tetap menghadap matahari sepanjang hari: sensor mengukur dari mana cahaya datang dan motor memutar panel ke arah itu. Rakitan Arduino yang umum memakai empat LDR (resistor yang bergantung pada cahaya) dan dua motor servo. LDR memberi tahu board sisi mana yang lebih terang, lalu servo memutar panel ke sisi itu. Panel tetap melihat matahari dari samping pada pagi dan sore hari sehingga kehilangan sebagian besar energi yang tersedia, sedangkan panel yang melacak menangkap cahaya mendekati sudut siku-siku di setiap jam sepanjang hari.

Di panduan ini kamu akan mempelajari langkah demi langkah perbedaan pelacakan satu sumbu dan dua sumbu, cara menghitung selisih cahaya dengan 4 LDR, logika dead band (toleransi) yang mencegah servo bergetar tanpa alasan, dan struktur mekanis yang menopang panel. Selain kode siap kompilasi untuk Arduino Uno, ESP32, dan Raspberry Pi Pico, kamu juga akan menemukan percobaan yang benar-benar mengukur pertambahan energi dengan membandingkan panel pelacak dengan panel tetap, daftar komponen, dan tips untuk mempresentasikan proyek di pameran sains.

Apa itu pelacak matahari dan mengapa bisa menaikkan output?

Daya yang dihasilkan panel bergantung pada sudut cahaya yang mengenai permukaannya. Ketika cahaya datang tegak lurus ke permukaan, panel menangkap cahaya paling banyak; ketika cahaya datang miring, berkas yang sama tersebar di area yang lebih luas dan intensitas yang diterima panel turun sebesar kosinus sudut datang. Karena itu cahaya yang datang 60° dari garis tegak lurus hanya menghasilkan separuh daya cahaya yang mengenai panel secara langsung. Tabel di bawah ini menunjukkan kehilangan tersebut. Kalau kamu perhatikan baik-baik, kamu juga akan melihat bahwa kesalahan kecil hampir tidak ada ruginya: panel yang meleset 5° dari matahari hanya kehilangan 0,4% dayanya. Fakta ini nanti kamu perlukan ketika memilih dead band.

Posisi matahari di langit dijelaskan dengan dua sudut: azimut, yang menunjukkan ke arah mana matahari berada di sepanjang cakrawala, dan elevasi (ketinggian), yang menunjukkan seberapa tinggi matahari di atas cakrawala. Karena Bumi berputar 15° per jam, matahari bergerak rata-rata sekitar 1° di langit setiap 4 menit, sedangkan elevasinya berubah banyak mengikuti musim. Di sekitar 39° lintang utara (kira-kira lintang Washington D.C., Lisbon, atau Turki bagian tengah) nilainya seperti ini:

Azimut diukur searah jarum jam dari utara. Ada dua kesimpulan penting dari tabel ini. Pada musim panas matahari terbit di timur laut dan terbenam di barat laut, jadi dalam sehari matahari menempuh sekitar 240°; servo yang berputar 180° tidak bisa menghadap matahari sepenuhnya pada jam-jam pertama dan terakhir siang hari, tetapi kerugiannya kecil karena pada waktu itu matahari rendah dan lemah. Pada musim dingin matahari tetap rendah bahkan di tengah hari, jadi panel tetap yang menghadap selatan butuh kemiringan berbeda untuk setiap musim. Pelacak menyelesaikan kedua masalah ini sendiri.

Satu sumbu atau dua sumbu?

Pelacak satu sumbu hanya mengikuti gerakan matahari dari timur ke barat; kemiringannya tetap dan diatur ke sudut yang sesuai dengan musim. Sumbu ini memberikan sebagian besar pertambahan, karena gerakan harian matahari yang terbesar adalah dari timur ke barat. Pelacakan satu sumbu juga jenis yang paling umum di pembangkit listrik tenaga surya besar; sistem dua sumbu mengumpulkan sedikit lebih banyak energi, tetapi lebih mahal dan butuh perawatan lebih banyak. Namun untuk proyek sekolah, dua sumbu menghasilkan demo yang lebih mengesankan dan merupakan soal bagus yang mengajarkanmu mengendalikan dua sumbu sekaligus.

Mengukur selisih cahaya: 4 LDR dan dinding bayangan

Satu LDR hanya memberi tahu seberapa terang sekelilingnya; untuk menemukan arah, kamu harus membandingkan minimal dua LDR. Di pelacak dua sumbu, keempat LDR disusun dalam persegi 2×2, dengan sekat buram berbentuk salib (+) di antaranya, yaitu dinding bayangan. Ketika sensor mengarah tepat ke matahari, dinding tidak menimbulkan bayangan pada LDR mana pun dan keempatnya menerima cahaya yang sama. Ketika matahari bergeser ke satu sisi, dinding menaungi LDR di sisi yang berlawanan dan pembacaannya turun. Tinggi dinding menentukan kepekaan: dinding 3 cm menimbulkan bayangan selebar sekitar 2,6 mm pada pergeseran 5° (3 cm × tan 5°), cukup untuk menutupi separuh LDR 5 mm. Dinding yang tinggi menghasilkan sensor yang lebih peka tetapi lebih sempit, dinding yang pendek menghasilkan sensor yang lebih kasar tetapi lebih lebar. Untuk melihat cara kerja LDR secara detail, baca Sensor Cahaya LDR.

• Rata-rata atas: (kiri atas + kanan atas) / 2
• Rata-rata bawah: (kiri bawah + kanan bawah) / 2
• Rata-rata kiri: (kiri atas + kiri bawah) / 2
• Rata-rata kanan: (kanan atas + kanan bawah) / 2
• Selisih vertikal (dV): atas − bawah. Kalau positif panel harus miring ke atas, kalau negatif ke bawah.
• Selisih horizontal (dH): kiri − kanan. Kalau positif panel harus berputar ke kiri, kalau negatif ke kanan.

Melacak dengan sensor atau dengan jam?

Pelacakan dengan LDR bukan satu-satunya cara. Karena posisi matahari bisa dihitung terlebih dahulu dari tanggal, waktu, dan lokasi, sebagian sistem sama sekali tidak memakai sensor cahaya. Mari bandingkan ketiga pendekatan:

Di panduan ini kita membuat versi berbasis sensor, karena tidak butuh data lokasi atau waktu, mudah dipasang, dan mengoreksi kesalahan mekanis sendiri. Kalau kamu ingin mengembangkan proyek lebih jauh, menambahkan pelacakan berbasis jam dengan modul RTC nanti lalu membandingkan kedua metode menjadi percobaan tambahan yang sangat kuat di depan juri.

Daftar komponen

Pengkabelan: Arduino Uno, ESP32, dan Pico

Satu kaki setiap LDR disambungkan ke catu daya (5V di Uno, 3V3 di ESP32 dan Pico) dan kaki lainnya ke pin analog; resistor tetap dipasang dari pin analog yang sama ke GND. Dengan begitu pembacaannya naik ketika cahaya bertambah. Di sisi panel, sebuah resistor beban (33 Ω) dipasang di antara kedua terminal setiap panel. Tegangan panel dibagi 3,2 dengan pembagi 22 kΩ dan 10 kΩ sebelum sampai ke pin analog: 22 kΩ dari terminal positif panel ke pin analog, 10 kΩ dari pin analog ke GND. Terminal negatif panel juga harus disambungkan ke GND board; tanpa ground bersama, pengukurannya tidak bermakna.

Mekanik: braket pan-tilt dan keseimbangan panel

Solusi mekanis termudah adalah braket pan-tilt siap pakai yang menumpuk dua servo SG90: servo bawah memutar panel secara horizontal (timur–barat), servo atas memiringkannya secara vertikal. Pasang blok sensor di tepi panel sehingga permukaannya benar-benar sejajar dengan permukaan panel. Kalau sensor mengarah ke arah yang berbeda dari panel, sistem akan melacak matahari dengan sempurna sementara panelnya selalu meleset beberapa derajat. Panel mini 6 V 1 W berukuran 110×60 mm beratnya sekitar 22 g; pada jarak 3 cm dari sumbu, artinya torsi sekitar 0,07 kg·cm, jauh di bawah 1,8 kg·cm milik SG90. Beban sebenarnya adalah angin: kalau kamu menguji di luar ruangan, letakkan panel di tengah sumbu servo, pakai MG90S yang bergigi logam, dan untuk panel yang lebih besar pindah ke servo kuat seperti MG996R. Sisakan lilitan kabel yang longgar untuk putaran; kabel yang tegang membebani servo dan menarik lepas sambungan. Untuk dasar-dasar servo, baca Apa Itu Motor Servo?.

Perakitan langkah demi langkah

1. Solder keempat LDR ke sepotong perfboard dalam persegi 2×2, lalu tempel sekat berbentuk salib dari karton atau cetak 3D setinggi 2–3 cm di antaranya; cat dengan hitam doff atau tutup dengan selotip hitam.
2. Buat pembagi untuk setiap LDR: LDR dari catu daya ke pin analog, resistor tetap dari pin analog ke GND.
3. Pasang servo ke braket pan-tilt, atur keduanya ke 90°, lalu pasang horn-nya di posisi tengah dengan sekrup.
4. Pasang panel dan blok sensor di braket atas dengan permukaan yang sejajar.
5. Buat rangkaian pengukur panel: resistor beban di antara terminal panel, pembagi antara terminal positif panel dan GND, titik tengahnya ke A4.
6. Beri daya servo dari catu daya 5 V eksternal, satukan semua GND, dan pasang kapasitor 470 µF paralel dengan catu daya servo.
7. Upload kode kalibrasi dulu, lalu kode pelacakan, dan uji sistem dengan senter.

Langkah 1: Uji dan kalibrasi LDR

Bahkan LDR dari kantong yang sama memberikan pembacaan yang jelas berbeda di bawah cahaya yang sama; datasheet GL5528 menyebutkan rentang selebar 10–20 kΩ pada 10 lux. Sensor yang belum dikalibrasi mengira satu sisi lebih terang bahkan ketika mengarah tepat ke matahari, lalu memutar panel beberapa derajat ke arah yang salah. Upload kode di bawah ini, buka Serial Plotter dari menu Tools, dan sinari blok sensor secara merata; misalnya, selembar kertas putih yang dibentangkan di depan lampu akan menyebarkan dan meratakan cahaya.

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}

Keempat garis harus berada di tingkat yang sama di bawah cahaya yang sama. Misalkan pembacaannya 612, 640, 598, dan 625; rata-ratanya 619. Koreksi setiap LDR adalah rata-rata dikurangi nilainya sendiri: +7, −21, +21, dan −6. Angka-angka ini kamu masukkan ke array OFFSET di kode langkah 3. Karena hambatan LDR tidak berubah secara linear terhadap cahaya, kalibrasi pada tingkat cahaya yang mendekati kondisi kerja sistem yang sebenarnya memberikan hasil paling akurat. Serial Plotter juga menunjukkan noise-nya: catat berapa count pembacaan bergeser ketika kamu tidak menyentuh apa pun, karena angka itu kamu perlukan ketika memilih dead band.

Langkah 2: Kode pelacak matahari satu sumbu

Mari lihat logikanya pada satu sumbu dulu. Dua LDR, dipisahkan oleh dinding bayangan vertikal, menghadap sisi timur dan barat: A0 adalah LDR timur dan A1 LDR barat. Kode mengurangkan satu pembacaan dari yang lain; kalau selisihnya lebih besar dari dead band, servo berputar 1° ke sisi yang lebih terang, kalau tidak, servo diam. Sketch pendek ini sudah merupakan sistem satu sumbu yang lengkap. Kalau panel malah menjauhi cahaya, tukar angle++ dan angle-- di kedua kondisi.

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}

Dengan delay(30) servo berputar paling banyak 1° setiap 30 ms, yaitu sekitar 33° per detik, jadi panel dengan mudah mengikuti senter selama demo. Matahari bergerak jauh lebih pelan, jadi dalam pemakaian sebenarnya koreksi setiap beberapa detik sudah cukup.

Langkah 3: Kode dua sumbu, dead band, dan pencatatan data

Versi lengkapnya menghitung dua selisih dari empat LDR, mengoreksi setiap sumbu secara terpisah, memarkir panel agar siap untuk pagi hari ketika malam tiba, dan sekali per menit menulis tegangan, daya, dan energi yang terkumpul dari kedua panel ke Serial Monitor sebagai CSV. Kode memakai millis() alih-alih delay(), sehingga pelacakan dan pencatatan berjalan tanpa saling menunggu. Detail teknik ini ada di millis dan delay.

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}

Mencegah getaran dengan dead band (toleransi)

Tanpa dead band, sistem tidak pernah diam. Bahkan ketika mengarah tepat ke matahari, pembacaan LDR bergeser beberapa count karena noise, selisihnya bergantian antara plus dan minus, dan servo terus melangkah 1° ke kanan, 1° ke kiri. Getaran ini mengikis gigi servo dan membuang energi. Solusinya adalah mengabaikan selisih kecil: kalau selisihnya di bawah batas tertentu, tidak ada yang terjadi. Pakai noise yang kamu lihat selama kalibrasi untuk memilih batasnya, dan buat dead band minimal 3–4 kali noise. Di Uno, kalau noise-nya sekitar ±5 count, 20–40 adalah titik awal yang bagus.

Metode di kode melangkah lebih jauh: histeresis. Servo mulai bergerak ketika selisihnya melebihi 40, tetapi tidak berhenti sampai selisihnya turun di bawah 15. Dengan dead band satu batas, panel berhenti tepat di tepi batas dan awan kecil atau embusan angin membuatnya bergerak lagi; sistem dua batas membawa panel benar-benar menghadap matahari setiap kali, lalu tenang. Pengaruh dead band terhadap energi juga bisa diabaikan: seperti ditunjukkan tabel kosinus, kesalahan beberapa derajat berarti kerugian di bawah 1%. Untuk teknik penyaringan lainnya, baca menyaring data sensor.

Percobaan efisiensi: panel pelacak vs panel tetap

Satu-satunya cara membuktikan bahwa pelacak bekerja adalah dengan mengukurnya. Kesalahan umum di sini adalah hanya mengukur tegangan rangkaian terbuka panel. Tegangan tanpa beban panel hampir tidak berubah terhadap cahaya: ketika cahaya berkurang separuh, arusnya kira-kira juga berkurang separuh, tetapi tegangan rangkaian terbuka hanya turun 3–5%. Jadi kedua panel menunjukkan sekitar 7 V dan selisihnya hilang. Cara yang benar adalah memasang resistor beban yang sama di setiap panel dan mengukur tegangan di resistor itu. Daya dihitung dengan P = V² / R, dan energi dengan menjumlahkan daya sepanjang waktu. Pilih resistor beban untuk titik daya maksimum panel: panel 6 V 1 W menghasilkan sekitar 1 / 6 = 0,17 A, jadi resistor yang cocok adalah 6 / 0,17 ≈ 36 Ω; resistor standar 33 Ω pilihan yang bagus. Karena resistor membuang hampir 1 W sebagai panas, pakai resistor keramik minimal 2 W, sebaiknya 5 W. Kamu bisa mengecek angkanya dengan kalkulator hukum Ohm.

1. Pakai dua panel identik: model yang sama, idealnya dari batch produksi yang sama. Pasang resistor beban 33 Ω dan pembagi 22 kΩ / 10 kΩ di keduanya; panel pelacak ke A4, panel tetap ke A5.
2. Lakukan uji awal: pasang kedua panel berdampingan dengan arah dan kemiringan yang sama, lalu ukur selama 30–60 menit. Catat selisihnya (misalnya 2%) dan koreksi hasilmu dengan angka itu. Lebih baik lagi, tukar posisi panel pada hari kedua.
3. Arahkan panel tetap tepat ke selatan dan atur kemiringannya untuk matahari tengah hari pada hari itu (lihat peringatan di bawah).
4. Letakkan kedua panel cukup berjauhan agar tidak saling menaungi atau menaungi sensor, di tempat tanpa bayangan pohon atau tembok.
5. Ukur tegangan panel sekali dengan multimeter dan bandingkan dengan pembacaan Arduino; kalau berbeda, koreksi nilai DIVIDER (cara memakai multimeter).
6. Catat data sekali per menit dari matahari terbit sampai terbenam dan tulis kondisi cuacanya (cerah, berawan sebagian, mendung).
7. Ulangi percobaan minimal tiga hari cerah, catat satu hari mendung secara terpisah, lalu bandingkan rata-rata energi hariannya.

Kamu bisa menyalin data dari Serial Monitor dan menyimpannya sebagai file CSV atau mengalirkannya langsung ke Excel (mengirim data Arduino ke Excel); kalau tidak mau duduk di samping komputer, tambahkan modul kartu SD. Di grafik hari yang cerah, garis panel pelacak tetap jelas di atas pada pagi dan sore hari, sedangkan sekitar tengah hari kedua garis hampir berimpit. Untuk sistem besar, pertambahan energi yang dilaporkan sekitar 15–35% dengan pelacakan satu sumbu dan 30–45% dengan dua sumbu; dengan rakitan mini, hasilnya sangat bergantung pada cuaca, musim, dan seberapa baik arah panel tetap. Tulis dengan jelas di laporanmu bahwa yang kamu ukur bukan efisiensi panel itu sendiri, melainkan peningkatan energi yang dikumpulkan panel yang sama. Tambahkan juga satu keterbatasan: dengan resistor beban tetap, daya berubah sebanding dengan kuadrat arus, jadi ketika cahaya melemah, daya panel turun lebih cepat daripada cahayanya; karena itu persentase pertambahan yang kamu ukur bisa lebih tinggi daripada sistem sungguhan yang memakai charge controller. Kalau kamu juga menjumlahkan dan membandingkan arus kedua panel (V / R), kamu akan melihat seberapa besar sebenarnya perbedaan cahaya yang sampai ke panel.

Anggaran energi: bisakah sistem memberi daya untuk dirinya sendiri?

Ini pertanyaan favorit juri. Pelacak menambah energi, tetapi juga memakai sebagian. Untuk model mini, angka kasarnya seperti ini:

Tabel ini memperjelas: model mini tidak bisa menghasilkan energi yang cukup untuk menjalankan elektroniknya sendiri. Tambahan sekitar 1–1,5 Wh dari pelacakan itu kecil dibandingkan sekitar 6 Wh yang dipakai Uno per hari. Itu bukan kegagalan; itu hasil yang jujur dan berharga. Ketika skalanya membesar, gambarannya berbalik: konsumsi motor dan pengendali yang memutar panel berukuran kilowatt menjadi bagian kecil dari output. Untuk mengurangi konsumsi pada sistem mini, koreksi sekali per menit, lepaskan servo dengan detach() ketika tidak bergerak, dan pilih Pro Mini yang bisa sleep atau ESP32 dengan deep sleep alih-alih Uno. Untuk memperkirakan lama pemakaian baterai, pakai kalkulator umur baterai dan panduan mAh dan Wh.

Pelacakan matahari dengan ESP32 dan pemantauan dari ponselmu

ESP32 menjalankan logika yang sama dengan ADC yang lebih halus dan Wi-Fi. Ada beberapa perbedaan yang perlu diperhatikan. Pembacaan analog berkisar dari 0 sampai 4095, jadi dead band-nya sekitar 4 kali milik Uno. Dengan Wi-Fi menyala, hanya pin ADC1 (GPIO 32–39) yang bekerja dengan andal, karena pin ADC2 dipakai oleh driver Wi-Fi. Untuk servo, instal library ESP32Servo dari Library Manager. Fungsi analogReadMilliVolts() yang dipakai untuk mengukur tegangan panel mengoreksi perilaku ADC ESP32 yang tidak linear dengan kalibrasi pabrik. Selalu beri daya pembagi LDR dari 3V3. Setelah upload, buka alamat IP yang tampil di Serial Monitor di ponsel yang terhubung ke jaringan yang sama, dan kamu akan melihat tegangan langsung kedua panel, energi yang terkumpul, dan pertambahannya. Kalau kamu baru mengenal ESP32, mulai dari Apa Itu ESP32?.

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}

Kalau ingin menyimpan hasil ukur selama berhari-hari, kamu bisa mengirim nilai yang sama ke spreadsheet online; baca mencatat data ESP32 ke Google Sheets. Penjelasan lebih lanjut tentang resolusi ADC dan tegangan referensi ada di ADC dan konversi analog ke digital.

Pelacakan satu sumbu dengan Raspberry Pi Pico dan MicroPython

Pico hanya menyediakan tiga input analog (GP26, GP27, GP28), yang tidak cukup untuk empat LDR dan dua panel. Karena itu solusi Pico yang paling rapi adalah pelacak satu sumbu: dua LDR mencari arah dan input analog ketiga mengukur tegangan panel. Untuk dua sumbu kamu bisa menambahkan ADC I2C eksternal seperti ADS1115 yang punya 4 kanal. Servo dikendalikan langsung dengan PWM 50 Hz: pulsa 500 µs berarti 0°, pulsa 2400 µs berarti 180°. Karena read_u16() mengembalikan nilai pada skala 0–65535, dead band-nya berupa angka besar seperti 2000. Cara menginstal MicroPython di Pico ada di Apa Itu Raspberry Pi Pico?.

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)

Kode menambahkan hasil ukur ke file log.csv di memori flash Pico sendiri. Satu baris per menit menghasilkan 30–40 KB per hari, jadi sistem file Pico yang sekitar 1,4 MB cukup untuk berminggu-minggu. Kalau file disimpan sebagai main.py, Pico menjalankan program sendiri begitu diberi daya dari baterai atau adaptor USB, tanpa komputer. Di akhir hari kamu bisa mengunduh log.csv ke komputermu dengan Thonny dan membukanya di Excel.

Tips presentasi di pameran sains

Pelacak matahari adalah proyek yang umum di pameran sains dan lomba sekolah; yang membuat proyekmu menonjol bukan modelnya, melainkan data hasil ukurmu dan cara kamu menafsirkannya. Untuk ide proyek dan struktur laporan, lihat juga ide proyek Arduino untuk lomba sains.

• Ajukan pertanyaan yang bisa diukur: Berapa persen energi tambahan yang dikumpulkan pelacakan dua sumbu pada hari cerah di musim gugur dibandingkan panel identik yang dipasang tetap pada sudut terbaik menghadap selatan?
• Tulis hipotesismu lebih dulu: Misalnya, perkirakan bahwa pertambahannya terpusat di pagi dan sore hari; bahkan kalau hasilnya tidak membuktikannya, membahas alasannya tetap menambah nilai.
• Pisahkan variabelnya: Variabel bebas adalah metode pelacakan (tanpa pelacakan, satu sumbu, dua sumbu), variabel terikat adalah energi harian (Wh), dan variabel kontrol adalah model panel, resistor beban, lokasi, dan tanggal.
• Ceritakan dengan grafik: Grafik garis waktu–daya menampilkan kedua panel bertumpuk; bandingkan energi harian dengan diagram batang dan tunjukkan sebaran antarhari sebagai batas kesalahanmu.
• Bahas energi bersih: Ukur konsumsi sistem sendiri dan cantumkan tabel anggaran energi di postermu; itu menunjukkan bahwa proyekmu jujur dan ilmiah.
• Di ruang pameran tidak ada matahari: Lakukan demo langsung dengan senter atau lampu sorot, dan bawa video time-lapse percobaan di luar ruangan serta file CSV mentahnya.
• Susun posternya: Masalah, metode, skema rangkaian, diagram alir kode, hasil, keterbatasan, dan saran; kalimat pendek dan grafik besar di setiap bagian.
• Sebutkan keterbatasannya sendiri: Menyebut batasan seperti panel yang kecil, data yang hanya beberapa hari, angin, dan perbedaan antar-LDR sebelum juri bertanya akan membangun kepercayaan.

Kesalahan umum dan solusinya

Ide untuk mengembangkan proyek lebih jauh

• Stasiun pengisian tenaga surya: Sambungkan panel pelacak ke modul pengisi daya TP4056 dan sel 18650, lalu bandingkan lama pengisiannya dengan panel tetap.
• Pelacakan hibrida: Hitung posisi matahari dengan modul jam RTC dan pakai LDR hanya untuk penyetelan halus; panel mengarah dengan benar bahkan pada hari berawan.
• Pencatatan data lewat Wi-Fi: Kirim hasil ukur dari ESP32 ke Google Sheets dan pantau grafiknya secara langsung di ponselmu.
• Rumah kaca bertenaga surya: Pakai panel pelacak untuk memberi daya kipas dan penyiraman pada model rumah kaca pintar.
• Pemindai cahaya: Buat versi yang menyapu satu LDR dari 0 sampai 180° dengan servo dan menemukan arah paling terang; logikanya sangat mirip dengan proyek radar Arduino.
• Pengukuran daya yang lebih presisi: Selain resistor beban, pakai sensor daya I2C seperti INA219 yang mengukur arus dan tegangan sekaligus, lalu gambarkan kurva daya panel.

Pelacak matahari menggabungkan pembacaan sensor, pengambilan keputusan, kendali motor, dan pengukuran ilmiah dalam satu proyek, sehingga menjadi pilihan bagus untuk belajar sekaligus untuk dipamerkan di lomba. Mulai dari satu sumbu, setel dead band-nya, lalu tambahkan sumbu kedua dan percobaan panel tetap. Di aplikasi BlueGrays kamu akan menemukan proyek yang memungkinkanmu mencoba setiap bagian sistem ini secara terpisah, seperti mengukur cahaya dengan LDR, lampu tidur, kendali sudut servo, dan voltmeter digital, masing-masing dengan skema rangkaian dan kode.