Solartracker mit Arduino: Sonnennachführung mit 4 LDRs und Servos

Ein Solartracker mit Arduino ist eine automatische Sonnennachführung, die ein Solarmodul den ganzen Tag zur Sonne ausrichtet: Sensoren messen, aus welcher Richtung das Licht kommt, und ein Motor dreht das Modul dorthin. Ein typischer Arduino-Aufbau besteht aus vier LDRs (lichtabhängigen Widerständen) und zwei Servomotoren. Die LDRs melden, welche Seite heller ist, und die Servos drehen das Modul zu dieser Seite. Ein festes Modul sieht die Sonne morgens und abends nur von der Seite und verschenkt einen großen Teil der Energie; ein nachgeführtes Modul fängt das Licht zu jeder Tageszeit nahezu senkrecht ein.

In diesem Ratgeber lernst du Schritt für Schritt den Unterschied zwischen ein- und zweiachsiger Nachführung, wie der Lichtunterschied mit 4 LDRs berechnet wird, die Logik der Totzone (Toleranz), die das sinnlose Zittern des Servos verhindert, und die Mechanik, die das Modul trägt. Neben kompilierfertigem Code für Arduino Uno, ESP32 und Raspberry Pi Pico findest du einen Versuchsaufbau, der den Energiegewinn wirklich misst, indem er das nachgeführte Modul mit einem festen vergleicht, außerdem eine Teileliste und Tipps für die Präsentation bei Jugend forscht oder einem Schulwettbewerb.

Was ist ein Solartracker und warum steigert er den Ertrag?

Die Leistung eines Solarmoduls hängt vom Winkel ab, unter dem das Licht auf die Oberfläche trifft. Fällt das Licht senkrecht ein, fängt das Modul am meisten Licht ein; je schräger es kommt, desto größer ist die Fläche, auf die sich derselbe Lichtstrahl verteilt, und die Bestrahlungsstärke auf dem Modul sinkt mit dem Kosinus des Einfallswinkels. Deshalb liefert Licht, das 60° von der Senkrechten abweicht, nur halb so viel Leistung wie senkrecht einfallendes Licht. Die folgende Tabelle zeigt diesen Verlust. Wenn du genau hinschaust, siehst du auch, dass kleine Fehler fast nichts kosten: Ein Modul, das die Sonne um 5° verfehlt, verliert nur 0,4 % seiner Leistung. Das brauchst du später bei der Wahl der Totzone.

Der Sonnenstand wird mit zwei Winkeln beschrieben: dem Azimut, also der Himmelsrichtung am Horizont, und der Sonnenhöhe (Elevation), also wie hoch die Sonne über dem Horizont steht. Weil sich die Erde pro Stunde um 15° dreht, wandert die Sonne im Mittel etwa 1° alle 4 Minuten über den Himmel, während sich ihre Höhe mit den Jahreszeiten stark ändert. Die Tabelle gilt für etwa 39° Nord (zum Beispiel Lissabon oder Valencia); in der Mitte Deutschlands (etwa 51° Nord) steht die Sonne mittags im Juni nur bei etwa 62° und im Dezember bei etwa 16°.

Der Azimut wird von Norden aus im Uhrzeigersinn gemessen. Aus der Tabelle folgen zwei wichtige Erkenntnisse. Im Sommer geht die Sonne im Nordosten auf und im Nordwesten unter und legt am Tag rund 240° zurück, in Deutschland sogar rund 260°; ein Servo mit 180° Drehbereich kann sich in den ersten und letzten Stunden nicht ganz zur Sonne drehen, doch der Verlust ist klein, weil die Sonne dann tief steht und schwach ist. Im Winter bleibt die Sonne selbst mittags niedrig, deshalb bräuchte ein festes, nach Süden ausgerichtetes Modul je nach Jahreszeit eine andere Neigung. Ein Tracker löst beide Probleme von selbst.

Einachsig oder zweiachsig?

Ein einachsiger Tracker folgt nur der Bewegung der Sonne von Osten nach Westen; seine Neigung ist fest und wird passend zur Jahreszeit eingestellt. Diese Achse bringt den größten Teil des Gewinns, weil die größte tägliche Bewegung der Sonne in Ost-West-Richtung verläuft. In großen Solarparks ist die einachsige Nachführung auch die häufigste Bauart; zweiachsige Systeme sammeln etwas mehr Energie, sind aber teurer und wartungsintensiver. Für ein Schulprojekt ist die zweiachsige Variante dagegen die eindrucksvollere Vorführung und eine schöne Aufgabe, bei der du lernst, zwei Achsen gleichzeitig zu regeln.

Den Lichtunterschied messen: 4 LDRs und eine Schattenwand

Ein einzelner LDR sagt dir nur, wie hell die Umgebung ist; um eine Richtung zu finden, musst du mindestens zwei LDRs vergleichen. Beim zweiachsigen Tracker sitzen die vier LDRs in einem 2×2-Quadrat, getrennt durch eine lichtundurchlässige, kreuzförmige (+) Trennwand, die Schattenwand. Zeigt der Sensor genau zur Sonne, wirft die Wand auf keinen LDR einen Schatten und alle vier sehen dasselbe Licht. Wandert die Sonne zur Seite, beschattet die Wand die LDRs auf der gegenüberliegenden Seite und deren Werte sinken. Die Höhe der Wand bestimmt die Empfindlichkeit: Eine 3 cm hohe Wand wirft bei 5° Abweichung einen etwa 2,6 mm breiten Schatten (3 cm × tan 5°), genug, um die Hälfte eines 5-mm-LDRs abzudecken. Eine hohe Wand ergibt einen empfindlicheren, aber engeren Sensor, eine niedrige einen gröberen mit größerem Erfassungswinkel. Wie ein LDR im Detail funktioniert, erfährst du unter LDR-Lichtsensor.

• Mittelwert oben: (oben links + oben rechts) / 2
• Mittelwert unten: (unten links + unten rechts) / 2
• Mittelwert links: (oben links + unten links) / 2
• Mittelwert rechts: (oben rechts + unten rechts) / 2
• Vertikale Differenz (dV): oben − unten. Ist sie positiv, muss das Modul nach oben kippen, ist sie negativ, nach unten.
• Horizontale Differenz (dH): links − rechts. Ist sie positiv, muss das Modul nach links drehen, ist sie negativ, nach rechts.

Nachführung per Sensor oder per Uhr?

Die Nachführung mit LDRs ist nicht die einzige Methode. Da sich der Sonnenstand aus Datum, Uhrzeit und Standort vorausberechnen lässt, kommen manche Systeme ganz ohne Lichtsensor aus. Hier die drei Ansätze im Vergleich:

In diesem Ratgeber bauen wir die sensorgeführte Variante, weil sie weder Standort noch Uhrzeit braucht, einfach einzurichten ist und mechanische Fehler selbst ausgleicht. Wenn du das Projekt erweitern willst, ist eine zusätzliche zeitgeführte Nachführung mit RTC-Modul und der Vergleich beider Methoden ein sehr starkes Zusatzexperiment vor der Jury.

Teileliste

Schaltung: Arduino Uno, ESP32 und Pico

Ein Bein jedes LDRs kommt an die Versorgung (beim Uno 5V, beim ESP32 und Pico 3V3), das andere an einen Analogpin; vom selben Analogpin führt ein Festwiderstand nach GND. So steigt der Messwert mit zunehmender Helligkeit. Auf der Modulseite kommt zwischen die beiden Anschlüsse jedes Moduls ein Lastwiderstand (33 Ω). Die Modulspannung wird mit einem Teiler aus 22 kΩ und 10 kΩ durch 3,2 geteilt, bevor sie den Analogpin erreicht: 22 kΩ vom Pluspol des Moduls zum Analogpin, 10 kΩ vom Analogpin nach GND. Auch der Minuspol des Moduls muss mit GND der Platine verbunden sein; ohne gemeinsame Masse ist die Messung sinnlos.

Mechanik: Pan-Tilt-Halterung und Gewichtsverteilung

Die einfachste Mechanik ist eine fertige Pan-Tilt-Halterung, die zwei SG90-Servos übereinander trägt: Der untere Servo dreht das Modul horizontal (Ost–West), der obere neigt es vertikal. Befestige den Sensorblock am Rand des Moduls so, dass seine Oberfläche genau parallel zur Moduloberfläche liegt. Zeigt der Sensor in eine andere Richtung als das Modul, verfolgt das System die Sonne perfekt, aber das Modul schaut immer ein paar Grad daneben. Ein 6-V-1-W-Minimodul mit 110×60 mm wiegt etwa 22 g; 3 cm von der Achse entfernt sind das rund 0,07 kg·cm Drehmoment, weit unter den 1,8 kg·cm des SG90. Die eigentliche Last ist der Wind: Wenn du draußen misst, setze das Modul mittig auf die Servoachse, nimm den MG90S mit Metallgetriebe und wechsle bei größeren Modulen zu einem kräftigen Servo wie dem MG996R. Lass den Kabeln eine lockere Schlaufe für die Drehung; ein straffes Kabel belastet den Servo und reißt Verbindungen ab. Grundlagen zu Servos findest du unter Was ist ein Servomotor?.

Aufbau Schritt für Schritt

1. Löte die vier LDRs im 2×2-Quadrat auf ein Stück Lochrasterplatine und klebe eine 2–3 cm hohe, kreuzförmige Trennwand aus Karton oder aus dem 3D-Drucker dazwischen; male sie mattschwarz an oder beklebe sie mit schwarzem Klebeband.
2. Baue für jeden LDR den Teiler auf: LDR von der Versorgung zum Analogpin, Festwiderstand vom Analogpin nach GND.
3. Setze die Servos in die Pan-Tilt-Halterung, stelle beide auf 90° und schraube die Servohebel in Mittelstellung fest.
4. Befestige Modul und Sensorblock auf der oberen Halterung, die Oberflächen parallel zueinander.
5. Baue die Messschaltung für das Modul: Lastwiderstand zwischen die beiden Modulanschlüsse, Teiler zwischen Pluspol und GND, Mittelpunkt an A4.
6. Versorge die Servos aus der externen 5-V-Quelle, verbinde alle GNDs und schalte den 470-µF-Kondensator parallel zur Servoversorgung.
7. Lade zuerst den Kalibriercode, dann den Tracking-Code hoch und teste das System mit einer Taschenlampe.

Schritt 1: LDRs testen und kalibrieren

Selbst LDRs aus derselben Tüte liefern bei gleichem Licht deutlich unterschiedliche Werte; das Datenblatt des GL5528 nennt bei 10 Lux eine Spanne von 10–20 kΩ. Ein unkalibrierter Sensor hält eine Seite für heller, obwohl er genau zur Sonne zeigt, und dreht das Modul ein paar Grad in die falsche Richtung. Lade den folgenden Code hoch, öffne über das Menü Werkzeuge den Seriellen Plotter und beleuchte den Sensorblock gleichmäßig; ein weißes Blatt Papier vor einer Lampe streut das Licht zum Beispiel schön gleichmäßig.

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}

Bei gleichem Licht sollten die vier Linien auf derselben Höhe liegen. Angenommen, die Werte sind 612, 640, 598 und 625; der Mittelwert ist 619. Die Korrektur jedes LDRs ist Mittelwert minus eigener Wert: +7, −21, +21 und −6. Diese Zahlen trägst du im Code aus Schritt 3 in das Array OFFSET ein. Weil sich der Widerstand eines LDRs nicht linear mit dem Licht ändert, kalibrierst du am genauesten bei einer Helligkeit, die der späteren Einsatzumgebung nahekommt. Im Seriellen Plotter siehst du außerdem das Rauschen: Notiere, um wie viele Stufen die Werte schwanken, während du nichts berührst; diese Zahl brauchst du für die Totzone.

Schritt 2: Code für den einachsigen Solartracker

Schauen wir uns die Logik zuerst an einer Achse an. Zwei LDRs, getrennt durch eine senkrechte Schattenwand, zeigen nach Osten und Westen: A0 ist der Ost-LDR, A1 der West-LDR. Der Code zieht die beiden Werte voneinander ab; ist die Differenz größer als die Totzone, dreht der Servo um 1° zur helleren Seite, sonst bleibt er stehen. Dieser kurze Sketch ist bereits ein vollständiger einachsiger Tracker. Flieht das Modul vor dem Licht, vertausche angle++ und angle-- in den beiden Bedingungen.

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}

Mit delay(30) dreht der Servo höchstens 1° alle 30 ms, also etwa 33° pro Sekunde, und folgt bei einer Vorführung mühelos einer Taschenlampe. Die Sonne bewegt sich viel langsamer, deshalb reicht im echten Betrieb eine Korrektur alle paar Sekunden.

Schritt 3: Zweiachsiger Code, Totzone und Datenaufzeichnung

Die Vollversion berechnet aus den vier LDRs zwei Differenzen, korrigiert jede Achse einzeln, parkt das Modul nachts in der Morgenposition und schreibt einmal pro Minute Spannung, Leistung und gesammelte Energie beider Module als CSV in den Seriellen Monitor. Der Code nutzt millis() statt delay(), damit Nachführung und Aufzeichnung nicht aufeinander warten. Mehr dazu unter millis statt 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}

Zittern mit einer Totzone (Toleranz) verhindern

Ohne Totzone kommt das System nie zur Ruhe. Selbst wenn es genau zur Sonne zeigt, schwanken die LDR-Werte wegen des Rauschens um ein paar Stufen, die Differenz springt zwischen Plus und Minus, und der Servo läuft ständig 1° nach rechts, 1° nach links. Dieses Zittern verschleißt das Getriebe und verschwendet Energie. Die Lösung: Kleine Differenzen werden ignoriert; liegt die Differenz unter einer bestimmten Grenze, passiert nichts. Nutze für die Grenze das Rauschen aus der Kalibrierung und wähle die Totzone mindestens 3- bis 4-mal so groß. Rauscht der Uno um etwa ±5 Stufen, sind 20–40 ein guter Startwert.

Der Code geht noch einen Schritt weiter: Hysterese. Der Servo startet, wenn die Differenz 40 übersteigt, hält aber erst an, wenn sie unter 15 fällt. Bei einer Totzone mit nur einer Grenze bleibt das Modul genau an der Grenze stehen, und eine kleine Wolke oder Böe setzt es wieder in Bewegung; das System mit zwei Grenzen führt das Modul jedes Mal sauber auf die Sonne und kommt dann zur Ruhe. Der Energieverlust durch die Totzone ist vernachlässigbar: Wie die Kosinustabelle zeigt, bedeuten ein paar Grad Abweichung weniger als 1 % Verlust. Weitere Filtermethoden findest du unter Sensordaten filtern.

Ertragsversuch: nachgeführtes gegen festes Solarmodul

Ob der Tracker etwas bringt, beweist nur eine Messung. Der häufigste Fehler dabei: nur die Leerlaufspannung des Moduls zu messen. Die Spannung ohne Last ändert sich mit dem Licht kaum: Halbiert sich das Licht, halbiert sich auch ungefähr der Strom, die Leerlaufspannung sinkt aber nur um 3–5 %. Beide Module zeigen dann um die 7 V und der Unterschied verschwindet. Richtig ist es, an jedes Modul denselben Lastwiderstand anzuschließen und die Spannung darüber zu messen. Die Leistung ergibt sich aus P = V² / R, die Energie aus der Summe der Leistung über die Zeit. Wähle den Lastwiderstand passend zum Punkt maximaler Leistung: Ein 6-V-1-W-Modul liefert etwa 1 / 6 = 0,17 A, der passende Widerstand ist also 6 / 0,17 ≈ 36 Ω; ein Normwert von 33 Ω ist eine gute Wahl. Weil der Widerstand fast 1 W in Wärme umsetzt, nimm mindestens 2 W, besser einen 5-W-Zementwiderstand. Zum Nachrechnen eignet sich der Rechner für das Ohmsche Gesetz.

1. Nimm zwei identische Module: gleiches Modell, möglichst aus derselben Charge. Schließe an beide einen 33-Ω-Lastwiderstand und einen Teiler 22 kΩ / 10 kΩ an; das nachgeführte Modul kommt an A4, das feste an A5.
2. Mach einen Vortest: Stell beide Module nebeneinander mit gleicher Richtung und Neigung auf und miss 30–60 Minuten lang. Notiere den Unterschied (zum Beispiel 2 %) und korrigiere deine Ergebnisse damit. Noch besser: Vertausche die Module am zweiten Tag.
3. Richte das feste Modul genau nach Süden aus und stelle die Neigung passend zur Mittagssonne des Tages ein (siehe Warnung unten).
4. Stelle die Module so weit auseinander, dass keins das andere oder den Sensor beschattet, an einem Ort ohne Baum- oder Wandschatten.
5. Miss die Modulspannung einmal mit einem Multimeter und vergleiche sie mit dem Arduino-Wert; weicht sie ab, korrigiere DIVIDER (Multimeter richtig benutzen).
6. Zeichne von Sonnenaufgang bis Sonnenuntergang einmal pro Minute auf und notiere das Wetter (klar, teils bewölkt, bedeckt).
7. Wiederhole den Versuch an mindestens drei klaren Tagen, zeichne einen bedeckten Tag zusätzlich auf und vergleiche den mittleren Tagesertrag.

Du kannst die Daten aus dem Seriellen Monitor kopieren und als CSV-Datei speichern oder direkt nach Excel übertragen (Arduino-Daten in Excel übertragen); wenn du nicht neben dem Rechner sitzen willst, ergänze ein SD-Kartenmodul. Im Diagramm eines klaren Tages liegt die Linie des nachgeführten Moduls morgens und abends deutlich höher, mittags liegen beide Linien fast übereinander. Für große Anlagen werden bei einachsiger Nachführung etwa 15–35 % und bei zweiachsiger 30–45 % Mehrertrag angegeben; bei einem Mini-Aufbau hängt das Ergebnis stark von Wetter, Jahreszeit und der Ausrichtung des festen Moduls ab. Schreib in deinem Bericht klar, dass du nicht den Wirkungsgrad des Moduls gemessen hast, sondern den Energiegewinn desselben Moduls. Nenne auch eine Grenze: An einem festen Lastwiderstand ändert sich die Leistung mit dem Quadrat des Stroms, deshalb fällt die Leistung des Moduls bei schwächerem Licht schneller als das Licht selbst; der gemessene prozentuale Gewinn kann daher höher ausfallen als in einer echten Anlage mit Laderegler. Summierst und vergleichst du zusätzlich die Ströme beider Module (V / R), siehst du zusätzlich, wie groß der Unterschied im einfallenden Licht wirklich ist.

Energiebilanz: Kann sich das System selbst versorgen?

Das ist die Lieblingsfrage jeder Jury. Ein Tracker gewinnt Energie, verbraucht aber auch welche. Für ein Mini-Modell sieht die grobe Rechnung so aus:

Die Tabelle zeigt es deutlich: Ein Mini-Modell erzeugt nicht genug Energie für die eigene Elektronik. Die rund 1–1,5 Wh Mehrertrag durch die Nachführung sind klein gegenüber den etwa 6 Wh, die der Uno pro Tag verbraucht. Das ist kein Scheitern, sondern ein ehrliches und wertvolles Ergebnis. Mit wachsender Größe kehrt sich das Bild um: Der Verbrauch von Motor und Steuerung, die Module im Kilowattbereich drehen, wird zu einem kleinen Bruchteil des Ertrags. Willst du den Verbrauch im Mini-System senken, korrigiere nur einmal pro Minute, gib die Servos im Stillstand mit detach() frei und nimm statt des Uno einen Pro Mini mit Schlafmodus oder einen ESP32 mit Deep Sleep. Die Laufzeit mit Akku berechnest du mit dem Akkulaufzeit-Rechner und dem Ratgeber mAh und Wh.

Solartracker mit ESP32 und Überwachung per Handy

Der ESP32 führt dieselbe Logik mit feinerem ADC und WLAN aus. Ein paar Unterschiede solltest du beachten. Die Analogwerte reichen von 0 bis 4095, deshalb ist die Totzone etwa viermal so groß wie beim Uno. Bei aktivem WLAN arbeiten nur die ADC1-Pins (GPIO 32–39) zuverlässig, weil die ADC2-Pins vom WLAN belegt werden. Für die Servos installierst du im Bibliotheksverwalter die Bibliothek ESP32Servo. Die Funktion analogReadMilliVolts(), mit der die Modulspannung gemessen wird, gleicht das nichtlineare Verhalten des ESP32-ADC mit der Werkskalibrierung aus. Versorge die LDR-Teiler unbedingt mit 3V3. Öffnest du nach dem Hochladen die im Seriellen Monitor angezeigte IP-Adresse auf einem Handy im selben Netz, siehst du die aktuelle Spannung beider Module, die gesammelte Energie und den Gewinn. Bist du neu beim ESP32, beginne mit Was ist der 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}

Willst du die Messwerte über Tage speichern, kannst du sie online in eine Tabelle schicken; siehe ESP32-Daten in Google Tabellen speichern. Mehr zu ADC-Auflösung und Referenzspannung steht unter ADC und Analog-Digital-Wandlung.

Einachsige Nachführung mit Raspberry Pi Pico und MicroPython

Der Pico hat nur drei herausgeführte Analogeingänge (GP26, GP27, GP28); für vier LDRs und zwei Module reicht das nicht. Die sauberste Lösung mit dem Pico ist deshalb ein einachsiger Tracker: Zwei LDRs finden die Richtung, der dritte Analogeingang misst die Modulspannung. Für zwei Achsen kannst du einen externen I2C-ADC wie den 4-kanaligen ADS1115 ergänzen. Der Servo wird direkt mit 50-Hz-PWM angesteuert: Ein Impuls von 500 µs bedeutet 0°, einer von 2400 µs 180°. Weil read_u16() Werte von 0 bis 65535 liefert, ist die Totzone eine große Zahl wie 2000. Wie du MicroPython auf den Pico bringst, steht unter Was ist der 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)

Der Code hängt die Messwerte an die Datei log.csv im Flash-Speicher des Pico an. Eine Zeile pro Minute ergibt 30–40 KB pro Tag, das rund 1,4 MB große Dateisystem des Pico reicht also für Wochen. Speicherst du die Datei als main.py, startet der Pico das Programm von selbst, sobald er über Akku oder USB-Netzteil Strom bekommt, ganz ohne Computer. Am Ende des Tages lädst du log.csv mit Thonny auf den Rechner und öffnest sie in Excel.

Tipps für Jugend forscht und Schulwettbewerbe

Solartracker sind bei Jugend forscht und Schulwettbewerben ein beliebtes Projekt; herausstechen wirst du nicht mit dem Modell selbst, sondern mit deinen gemessenen Daten und deren Auswertung. Ideen und den Aufbau eines Berichts findest du auch unter Arduino Projekte für die Schule.

• Stell eine messbare Frage: Wie viel Prozent mehr Energie sammelt eine zweiachsige Nachführung an einem klaren Herbsttag als ein baugleiches Modul, das im besten Winkel nach Süden fest montiert ist?
• Formuliere vorher eine Hypothese: Sag zum Beispiel voraus, dass sich der Gewinn auf Morgen und Abend konzentriert; auch wenn das Ergebnis sie nicht bestätigt, bringt die Diskussion Punkte.
• Trenne die Variablen: Unabhängige Variable ist die Nachführmethode (keine, einachsig, zweiachsig), abhängige Variable der Tagesertrag (Wh), kontrollierte Variablen sind Modultyp, Lastwiderstand, Standort und Datum.
• Erzähl mit Diagrammen: Ein Zeit-Leistungs-Liniendiagramm zeigt beide Module übereinander; vergleiche die Tageserträge im Säulendiagramm und gib die Schwankung zwischen den Tagen als Fehlerbereich an.
• Diskutiere die Nettoenergie: Miss den Eigenverbrauch des Systems und zeig die Energiebilanz auf dem Plakat; das beweist, dass das Projekt ehrlich und wissenschaftlich ist.
• In der Ausstellungshalle scheint keine Sonne: Mach die Live-Vorführung mit Taschenlampe oder Strahler und bring ein Zeitraffervideo des Außenversuchs und die rohe CSV-Datei mit.
• Gliedere das Plakat: Problem, Methode, Schaltplan, Programmablaufplan, Ergebnisse, Grenzen und Ausblick; in jedem Abschnitt kurze Sätze und große Diagramme.
• Nenne die Grenzen selbst: Kleines Modul, nur wenige Messtage, Wind und LDR-Unterschiede anzusprechen, bevor die Jury fragt, schafft Vertrauen.

Häufige Fehler und Lösungen

Ideen zum Weiterbauen

• Solar-Ladestation: Schließe das nachgeführte Modul an ein TP4056-Lademodul und eine 18650-Zelle an und vergleiche die Ladezeit mit dem festen Modul.
• Hybride Nachführung: Berechne den Sonnenstand mit einem RTC-Uhrmodul und nutze die LDRs nur zur Feinabstimmung; das Modul zeigt selbst bei Bewölkung in die richtige Richtung.
• Datenaufzeichnung per WLAN: Schick die Messwerte vom ESP32 an Google Tabellen und verfolge das Diagramm live auf dem Handy.
• Solarbetriebenes Gewächshaus: Versorge mit dem nachgeführten Modul Lüfter und Bewässerung eines smarten Gewächshauses im Modell.
• Lichtscanner: Baue eine Version, die einen einzelnen LDR per Servo von 0 bis 180° schwenkt und die hellste Richtung sucht; die Logik ähnelt stark dem Arduino-Radar-Projekt.
• Genauere Leistungsmessung: Ergänze den Lastwiderstand um einen I2C-Leistungssensor wie den INA219, der Strom und Spannung gemeinsam misst, und zeichne die Leistungskurve des Moduls auf.

Ein Solartracker verbindet Sensoren auslesen, Entscheidungen treffen, Motoren steuern und wissenschaftliches Messen in einem Projekt und ist deshalb ideal zum Lernen und zum Vorzeigen bei Wettbewerben. Fang mit einer Achse an, stimme die Totzone ab und ergänze dann die zweite Achse und den Versuch mit dem festen Modul. In der BlueGrays-App findest du Projekte, mit denen du jeden Teil dieses Systems einzeln ausprobieren kannst, etwa Lichtmessung mit dem LDR, ein Nachtlicht, Servo-Winkelsteuerung und ein Digitalvoltmeter, jeweils mit Schaltplan und Code.