Gidsen · 21 min leestijd

Arduino-solartracker: bouw met twee assen, 4 LDR's en servo's

Bouw een Arduino-solartracker: één of twee assen, 4 LDR's om het licht te vinden, servosturing, een dode zone tegen getril en een test tegen een vast zonnepaneel.

Een Arduino-solartracker is een automatisch mechanisme dat een zonnepaneel de hele dag op de zon gericht houdt: sensoren meten waar het licht vandaan komt en een motor draait het paneel ernaartoe. Een typische Arduino-bouw gebruikt vier LDR's (lichtgevoelige weerstanden) en twee servomotoren. De LDR's vertellen het board welke kant het helderst is en de servo's draaien het paneel naar die kant. Een vast paneel ziet de zon 's ochtends en 's avonds van opzij en mist een groot deel van de beschikbare energie, terwijl een meedraaiend paneel het licht op elk uur van de dag onder een bijna rechte hoek opvangt.

In deze gids leer je stap voor stap het verschil tussen volgen met één as en met twee assen, hoe het lichtverschil met 4 LDR's wordt berekend, de logica van de dode zone (tolerantie) die voorkomt dat de servo voor niets trilt, en de mechanische constructie die het paneel draagt. Naast code die direct te compileren is voor Arduino Uno, ESP32 en Raspberry Pi Pico vind je een experiment dat de energiewinst echt meet door het meedraaiende paneel met een vast paneel te vergelijken, een onderdelenlijst en tips om het project op een wetenschapsbeurs te presenteren.

LDR (lichtgevoelige weerstand) GL5528
LDR: de weerstand daalt naarmate er meer licht op valt. De ogen van een solartracker zijn vier LDR's die door een schaduwwand van elkaar gescheiden zijn.

Wat is een solartracker en waarom verhoogt hij de opbrengst?

Het vermogen dat een paneel levert, hangt af van de hoek waaronder het licht op het oppervlak valt. Valt het licht loodrecht op het oppervlak, dan vangt het paneel het meeste licht op; komt het schuin binnen, dan verspreidt dezelfde lichtbundel zich over een groter oppervlak en daalt de intensiteit die het paneel ziet met de cosinus van de invalshoek. Daarom levert licht dat 60° van de loodlijn afwijkt maar de helft van het vermogen van licht dat recht op het paneel valt. De tabel hieronder laat dit verlies zien. Kijk goed en je merkt ook dat kleine fouten bijna niets kosten: een paneel dat 5° langs de zon mikt, verliest slechts 0,4% van zijn vermogen. Dit gegeven heb je later nodig bij het kiezen van de dode zone.

Invalshoek (afwijking van de loodlijn)cos(hoek)Vermogen dat het paneel ontvangt
0°1,000100%
5°0,99699,6%
10°0,98598,5%
20°0,94094%
30°0,86687%
45°0,70771%
60°0,50050%
75°0,25926%

De positie van de zon aan de hemel wordt beschreven met twee hoeken: het azimut, dat aangeeft in welke richting langs de horizon de zon staat, en de elevatie (hoogte), die aangeeft hoe hoog de zon boven de horizon staat. Omdat de aarde 15° per uur draait, beweegt de zon gemiddeld ongeveer 1° per 4 minuten langs de hemel, terwijl de elevatie met de seizoenen sterk verandert. Rond 39° noorderbreedte (ongeveer de breedte van Washington D.C., Lissabon of Midden-Turkije) zien de waarden er zo uit:

DatumElevatie op het middaguurRichting zonsopkomstRichting zonsondergangDaglengte
21 juniOngeveer 74°Ongeveer 59° (noordoost)Ongeveer 301° (noordwest)Ongeveer 15 uur
21 maart en 23 septemberOngeveer 51°90° (precies oost)270° (precies west)Ongeveer 12 uur
21 decemberOngeveer 28°Ongeveer 121° (zuidoost)Ongeveer 239° (zuidwest)Ongeveer 9,5 uur

Het azimut wordt met de klok mee gemeten vanaf het noorden. Uit de tabel volgen twee belangrijke conclusies. In de zomer komt de zon op in het noordoosten en gaat onder in het noordwesten, dus hij legt overdag ongeveer 240° af; een servo die 180° draait, kan het paneel in de eerste en laatste uren van daglicht niet volledig op de zon richten, maar het verlies is klein omdat de zon dan laag staat en zwak is. In de winter blijft de zon zelfs op het middaguur laag, dus een vast paneel naar het zuiden heeft elk seizoen een andere kantelhoek nodig. Een tracker lost beide problemen zelf op.

Eén as of twee assen?

EigenschapEén asTwee assen
BewegingAlleen oost–westOost–west plus kanteling (omhoog–omlaag)
Aantal LDR's24
Aantal servo's12
Winst ten opzichte van een vast paneel (grote systemen)Ongeveer 15–35%Ongeveer 30–45%
MechaniekEenvoudig en robuustPan-tilthouder, meer onderdelen
CodeEén verschil, één beslissingTwee verschillen, twee assen tegelijk
Het meest geschikt voorEen eerste bouwproject, brugklasBovenbouw, wetenschapsbeurzen, efficiëntievergelijking

Een solartracker met één as volgt alleen de beweging van de zon van oost naar west; de kanteling ligt vast en is ingesteld op een hoek die bij het seizoen past. Deze as levert het grootste deel van de winst, omdat de grootste dagelijkse beweging van de zon van oost naar west gaat. Volgen met één as is ook het meest gebruikelijke type in grote zonneparken; systemen met twee assen vangen iets meer energie op, maar kosten meer en vragen meer onderhoud. Voor een schoolproject is twee assen echter een indrukwekkendere demo en een mooie uitdaging waarmee je leert twee assen tegelijk aan te sturen.

Het lichtverschil meten: 4 LDR's en een schaduwwand

Een enkele LDR vertelt alleen hoe helder de omgeving is; om een richting te vinden moet je minstens twee LDR's vergelijken. In een tracker met twee assen staan de vier LDR's in een vierkant van 2×2, met daartussen een ondoorzichtige kruisvormige (+) scheidingswand, de schaduwwand. Wijst de sensor recht naar de zon, dan werpt de wand op geen enkele LDR een schaduw en zien alle vier hetzelfde licht. Beweegt de zon naar één kant, dan beschaduwt de wand de LDR's aan de tegenovergestelde kant en dalen hun waarden. De hoogte van de wand bepaalt de gevoeligheid: een wand van 3 cm werpt bij 5° afwijking een schaduw van ongeveer 2,6 mm breed (3 cm × tan 5°), genoeg om de helft van een LDR van 5 mm te bedekken. Een hoge wand geeft een gevoeligere maar smallere sensor, een lage wand een grovere maar bredere. Hoe een LDR precies werkt, lees je in LDR-lichtsensor.

  • Gemiddelde boven: (linksboven + rechtsboven) / 2
  • Gemiddelde onder: (linksonder + rechtsonder) / 2
  • Gemiddelde links: (linksboven + linksonder) / 2
  • Gemiddelde rechts: (rechtsboven + rechtsonder) / 2
  • Verticaal verschil (dV): boven − onder. Is het positief, dan moet het paneel omhoog kantelen, is het negatief, dan omlaag.
  • Horizontaal verschil (dH): links − rechts. Is het positief, dan moet het paneel naar links draaien, is het negatief, dan naar rechts.
Elke LDR wordt als spanningsdeler met een vaste weerstand geschakeld. Je krijgt de gevoeligste meting als de vaste weerstand dicht bij de weerstand van de LDR ligt bij het lichtniveau waar het je om gaat. Voor tests binnen met een zaklamp of bureaulamp werkt 10 kΩ goed. In direct zonlicht zakt de LDR echter naar een paar honderd ohm, dus met 10 kΩ raken alle vier de waarden verzadigd rond 1000 en verdwijnt het verschil; gebruik buiten 1–2,2 kΩ. Waarden uitproberen kan met de spanningsdeler-calculator.

Volgen met sensoren of met een klok?

Volgen met LDR's is niet de enige methode. Omdat de positie van de zon vooraf te berekenen is uit datum, tijd en locatie, gebruiken sommige systemen helemaal geen lichtsensor. Laten we de drie benaderingen vergelijken:

MethodeHoe werkt het?VoordelenNadelen
Op sensoren (LDR, gesloten lus)Meet het lichtverschil en draait naar de helderste kantEenvoudig; geen locatie of tijd nodig; corrigeert mechanische fouten vanzelfInstabiel onder wolken; gevoelig voor reflecties en vuile sensoren
Op een klok (astronomisch, open lus)Berekent de positie van de zon uit datum, tijd en locatieWijst ook onder wolken de goede kant op; de beweging is vooraf geplandTijd, locatie en montagerichting moeten precies ingesteld zijn; merkt mechanische fouten niet op
HybrideKomt dichtbij door berekening, stemt fijn af met de LDR'sCombineert de sterke punten van beide methodenComplexere code en een extra RTC-module

In deze gids bouwen we de variant op sensoren, omdat die geen locatie- of tijdgegevens nodig heeft, makkelijk in te stellen is en mechanische fouten vanzelf corrigeert. Wil je het project verder uitbouwen, dan is het later toevoegen van volgen op een klok met een RTC-module en het vergelijken van de twee methoden een sterk extra experiment voor de jury.

Onderdelenlijst

OnderdeelAantalOpmerking
Arduino Uno (of Nano)1Een ESP32 of Raspberry Pi Pico werkt ook
LDR (GL5528, 5 mm)42 voor één as
Weerstand van 10 kΩ64 voor de LDR-spanningsdelers, 2 voor de paneelspanningsdelers; buiten 1–2,2 kΩ voor de LDR's
Weerstand van 22 kΩ2Spanningsdeler voor het paneel
Keramische (cement)weerstand van 33 Ω, 5 W2Eén belastingsweerstand per paneel
Servo SG90 of MG90S21 voor één as; MG90S op winderige plekken
Pan-tilthouder voor servo's1Kant-en-klare kunststof set of 3D-print
Mini-zonnepaneel 6 V 1 W (110×60 mm)2Eén volgt de zon, één is de vaste referentie
Condensator van 470 µF 16 V1Parallel aan de servovoeding
5 V 2 A-adapter of 4×AA NiMH-accu's1Externe voeding voor de servo's
Breadboard en jumperdraden1 setGaatjesprint voor een permanente bouw
Karton, zwarte tape of een 3D-geprinte scheidingswand1Kruisvormige schaduwwand
Arduino Uno
Arduino Uno
SG90
SG90
MG90S
MG90S
Breadboard
Breadboard

Bedrading: Arduino Uno, ESP32 en Pico

Eén pootje van elke LDR gaat naar de voeding (5V op de Uno, 3V3 op de ESP32 en Pico) en het andere pootje naar een analoge pin; een vaste weerstand loopt van dezelfde analoge pin naar GND. Zo stijgt de waarde als het licht toeneemt. Aan de paneelkant komt een belastingsweerstand (33 Ω) over de twee aansluitingen van elk paneel. De paneelspanning wordt met een deler van 22 kΩ en 10 kΩ door 3,2 gedeeld voordat hij de analoge pin bereikt: 22 kΩ van de pluspool van het paneel naar de analoge pin, 10 kΩ van de analoge pin naar GND. Ook de minpool van het paneel moet naar de GND van het board; zonder gemeenschappelijke massa is de meting zinloos.

AansluitingArduino UnoESP32Raspberry Pi Pico
LDR linksbovenA0GPIO 32GP26 (oost-LDR bij één as)
LDR rechtsbovenA1GPIO 33GP27 (west-LDR bij één as)
LDR linksonderA2GPIO 34Geen (externe ADC nodig)
LDR rechtsonderA3GPIO 35Geen (externe ADC nodig)
Volgend paneel (midden van de deler)A4GPIO 36 (VP)GP28
Vast paneel (midden van de deler)A5GPIO 39 (VN)Geen
Signaal horizontale servoD9GPIO 18GP15
Signaal verticale servoD10GPIO 19Geen (één as)
Voeding LDR-delers5V3V33V3
ServovoedingExterne 5 VExterne 5 VExterne 5 V
Alle GND's (inclusief de minpolen van de panelen)GNDGNDGND
Sluit een paneel nooit rechtstreeks aan op een analoge pin. De nullastspanning (open klemspanning) van een mini-paneel van 6 V kan in volle zon boven 7 V uitkomen; de pinnen van de Uno verdragen niet meer dan 5 V en de pinnen van de ESP32 en Pico niet meer dan 3,3 V. Met de deler van 22 kΩ / 10 kΩ komt 7,5 V als 2,34 V bij de pin aan. Voed de servo's ook niet via de 5V-pin van de Arduino; de stroom bij het bewegen laat het board resetten. Verbind de GND van de externe voeding met de GND van het board en zet een condensator van 470 µF over de servovoeding. Meer details staan in spanningsdeler en Arduino blijft resetten.

Mechaniek: pan-tilthouder en balans van het paneel

De eenvoudigste mechanische oplossing is een kant-en-klare pan-tilthouder waarin twee SG90-servo's op elkaar zitten: de onderste servo draait het paneel horizontaal (oost–west), de bovenste kantelt het verticaal. Monteer het sensorblok op de rand van het paneel zodat het vlak precies evenwijdig is aan het paneeloppervlak. Wijst de sensor een andere kant op dan het paneel, dan volgt het systeem de zon perfect terwijl het paneel steeds een paar graden naast de zon mikt. Een mini-paneel van 110×60 mm, 6 V en 1 W weegt ongeveer 22 g; op 3 cm van de as is dat ruwweg 0,07 kg·cm koppel, ver onder de 1,8 kg·cm van de SG90. De echte belasting is de wind: test je buiten, centreer het paneel dan op de servoas, gebruik de MG90S met metalen tandwielen en stap voor grotere panelen over op een sterke servo zoals de MG996R. Laat in de kabels een losse lus voor de draaiing; een strakke kabel belast de servo en trekt verbindingen los. Over de basis van servo's lees je meer in Wat is een servomotor?.

Montage stap voor stap

  1. Soldeer de vier LDR's in een vierkant van 2×2 op een stukje gaatjesprint en lijm er een kruisvormige scheidingswand van karton of 3D-print van 2–3 cm hoog tussen; verf hem matzwart of bedek hem met zwarte tape.
  2. Bouw de deler voor elke LDR: LDR van de voeding naar de analoge pin, vaste weerstand van de analoge pin naar GND.
  3. Monteer de servo's in de pan-tilthouder, zet beide op 90° en schroef de servohoorns in de middenstand vast.
  4. Bevestig het paneel en het sensorblok op de bovenste houder, met de vlakken evenwijdig.
  5. Bouw de meetschakeling voor het paneel: belastingsweerstand over de aansluitingen van het paneel, deler tussen de pluspool van het paneel en GND, middenpunt naar A4.
  6. Voed de servo's met de externe 5 V-voeding, verbind alle GND's en zet de condensator van 470 µF parallel aan de servovoeding.
  7. Upload eerst de kalibratiecode, dan de volgcode, en test het systeem met een zaklamp.

Stap 1: de LDR's testen en kalibreren

Zelfs LDR's uit hetzelfde zakje geven bij hetzelfde licht merkbaar verschillende waarden; de datasheet van de GL5528 noemt een bereik van wel 10–20 kΩ bij 10 lux. Een ongekalibreerde sensor denkt dat één kant helderder is, ook als hij recht op de zon wijst, en draait het paneel een paar graden de verkeerde kant op. Upload de onderstaande code, open de Serial Plotter in het menu Tools en belicht het sensorblok gelijkmatig; een vel wit papier voor een lamp verstrooit en egaliseert het licht bijvoorbeeld.

C++ (Arduino IDE)
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}

De vier lijnen moeten bij hetzelfde licht op hetzelfde niveau liggen. Stel dat de waarden 612, 640, 598 en 625 zijn; het gemiddelde is 619. De correctie van elke LDR is het gemiddelde min de eigen waarde: +7, −21, +21 en −6. Deze getallen vul je in de array OFFSET in de code van stap 3 in. Omdat de weerstand van een LDR niet lineair met het licht verandert, geeft kalibreren bij een lichtniveau dicht bij waar het systeem echt werkt het nauwkeurigste resultaat. De Serial Plotter laat ook de ruis zien: noteer hoeveel tellen de waarden schommelen terwijl je niets aanraakt, want dat getal heb je nodig bij het kiezen van de dode zone.

Stap 2: code voor een solartracker met één as

Laten we eerst de logica op één as bekijken. Twee LDR's, gescheiden door een verticale schaduwwand, kijken naar de oost- en westkant: A0 is de oost-LDR en A1 de west-LDR. De code trekt de ene waarde van de andere af; is het verschil groter dan de dode zone, dan draait de servo 1° naar de helderste kant, anders blijft hij staan. Deze korte sketch is een compleet systeem met één as. Draait het paneel van het licht weg, wissel dan angle++ en angle-- om in de twee voorwaarden.

C++ (Arduino IDE)
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}

Met delay(30) draait de servo hooguit 1° per 30 ms, ongeveer 33° per seconde, dus het paneel volgt tijdens een demo makkelijk een zaklamp. De zon beweegt veel langzamer, dus in het echte gebruik is een correctie om de paar seconden genoeg.

Stap 3: code voor twee assen, dode zone en datalogging

De volledige versie berekent twee verschillen uit de vier LDR's, corrigeert elke as apart, parkeert het paneel klaar voor de ochtend als het nacht wordt en schrijft één keer per minuut de spanning, het vermogen en de verzamelde energie van beide panelen als CSV naar de Serial Monitor. De code gebruikt millis() in plaats van delay(), zodat volgen en loggen niet op elkaar wachten. De details van deze techniek staan in millis en delay.

C++ (Arduino IDE)
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}
InstellingWaardeWat het doet
OFFSETCorrecties uit stap 1Heft de fabricageverschillen tussen de LDR's op
TOL_START / TOL_STOP40 / 15Dode zone met hysterese: draait als het verschil boven 40 komt, stopt als het onder 15 zakt
DIR_H / DIR_V1 of -1Keert de draairichting om zodat die bij jouw montage past
V_MIN / V_MAX10 / 90Grenzen van de verticale servo; voorkomen dat het paneel tegen de houder stoot
NIGHT60Ligt het gemiddelde van de vier LDR's hieronder, dan geldt het als nacht
H_PARK / V_PARK180 / 45Oostelijke stand waarin het paneel na 10 minuten duisternis wacht; wacht het naar het westen gericht, zet H_PARK dan op 0
DIVIDER / LOAD_OHM3.2 / 33Om de paneelspanning en het vermogen te berekenen met P = V² / R
LOG_MS60000Logginterval: één regel per minuut

Getril voorkomen met een dode zone (tolerantie)

Zonder dode zone komt het systeem nooit tot rust. Zelfs als hij recht op de zon wijst, schommelen de LDR-waarden door ruis een paar tellen, springt het verschil tussen plus en min en blijft de servo 1° naar rechts, 1° naar links stappen. Dit getril slijt de tandwielen van de servo en verspilt energie. De oplossing is kleine verschillen negeren: is het verschil onder een bepaalde grens, dan gebeurt er niets. Gebruik de ruis die je bij het kalibreren zag om de grens te kiezen en maak de dode zone minstens 3–4 keer de ruis. Op de Uno is 20–40 een goed beginpunt als de ruis rond ±5 tellen ligt.

De methode in de code gaat een stap verder: hysterese. De servo gaat bewegen als het verschil boven 40 komt, maar stopt pas als het onder 15 zakt. Bij een dode zone met één grens stopt het paneel precies aan de rand van de grens en zet een wolkje of windvlaag het weer in beweging; het systeem met twee grenzen brengt het paneel telkens ruim op de zon en komt dan tot rust. Het effect van de dode zone op de energie is ook verwaarloosbaar: zoals de cosinustabel liet zien, betekent een fout van een paar graden een verlies onder 1%. Meer filtertechnieken vind je in sensordata filteren.

Draai je een experiment de hele dag buiten, dan kun je om de 2–5 seconden corrigeren in plaats van elke 40 ms. Omdat de zon gemiddeld 1° per 4 minuten beweegt, blijft de volgnauwkeurigheid gelijk, terwijl de servo minder werkt, minder warm wordt en het systeem minder energie gebruikt.

Efficiëntie-experiment: meedraaiend paneel tegen vast paneel

De enige manier om te bewijzen dat de tracker werkt, is meten. De veelgemaakte fout is alleen de nullastspanning van het paneel meten. De spanning van een onbelast paneel verandert nauwelijks met het licht: halveert het licht, dan halveert de stroom ongeveer ook, maar de nullastspanning daalt slechts 3–5%. Beide panelen tonen dus rond 7 V en het verschil verdwijnt. De juiste methode is op elk paneel dezelfde belastingsweerstand aansluiten en de spanning erover meten. Het vermogen vind je met P = V² / R en de energie door het vermogen over de tijd op te tellen. Kies de belastingsweerstand voor het punt van maximaal vermogen van het paneel: een paneel van 6 V en 1 W levert ongeveer 1 / 6 = 0,17 A, dus de passende weerstand is 6 / 0,17 ≈ 36 Ω; een standaardwaarde van 33 Ω is een goede keuze. Omdat de weerstand bijna 1 W als warmte afgeeft, gebruik je minstens een keramische weerstand van 2 W, bij voorkeur 5 W. De getallen controleer je met de wet van Ohm-calculator.

  1. Gebruik twee identieke panelen: hetzelfde model, bij voorkeur uit dezelfde partij. Sluit op beide een belastingsweerstand van 33 Ω en een deler van 22 kΩ / 10 kΩ aan; het volgende paneel gaat naar A4, het vaste naar A5.
  2. Doe eerst een voortest: monteer beide panelen naast elkaar in dezelfde richting en met dezelfde kanteling en meet 30–60 minuten. Noteer het verschil (bijvoorbeeld 2%) en corrigeer je resultaten daarmee. Nog beter: wissel de panelen op de tweede dag om.
  3. Richt het vaste paneel precies op het zuiden en stel de kanteling in op de zon op het middaguur van die dag (zie de waarschuwing hieronder).
  4. Plaats de twee panelen ver genoeg uit elkaar zodat geen van beide het andere of de sensor beschaduwt, op een plek zonder schaduw van bomen of muren.
  5. Meet de paneelspanning één keer met een multimeter en vergelijk die met de waarde van de Arduino; verschillen ze, corrigeer dan de waarde DIVIDER (hoe gebruik je een multimeter).
  6. Log één keer per minuut van zonsopkomst tot zonsondergang en noteer het weer (helder, half bewolkt, bewolkt).
  7. Herhaal het experiment op minstens drie heldere dagen, log één bewolkte dag apart en vergelijk de gemiddelde dagelijkse energie.
KolomBetekenis
dkMinuten sinds de start van de Arduino
V_takip / V_sabitSpanning over de belastingsweerstand van het volgende / vaste paneel (V)
mW_takip / mW_sabitMomentaan vermogen: V² / R × 1000
mWh_takip / mWh_sabitEnergie verzameld sinds het begin van het loggen
Winst (%)(mWh_takip − mWh_sabit) / mWh_sabit × 100; dit bereken je in het spreadsheet

Je kunt de gegevens uit de Serial Monitor kopiëren en als CSV-bestand opslaan of rechtstreeks naar Excel streamen (Arduino-gegevens naar Excel sturen); wil je niet naast een computer zitten, voeg dan een SD-kaartmodule toe. In de grafiek van een heldere dag ligt de lijn van het volgende paneel 's ochtends en 's avonds duidelijk hoger, terwijl de twee lijnen rond het middaguur bijna samenvallen. Voor grote systemen worden energiewinsten van ongeveer 15–35% met één as en 30–45% met twee assen gemeld; bij een mini-opstelling hangt het resultaat sterk af van het weer, het seizoen en hoe goed het vaste paneel is gericht. Vermeld in je verslag duidelijk dat je niet het eigen rendement van het paneel hebt gemeten, maar de toename van de energie die hetzelfde paneel verzamelt. Voeg ook één beperking toe: bij een vaste belastingsweerstand verandert het vermogen met het kwadraat van de stroom, dus als het licht zwakker wordt, daalt het vermogen van het paneel sneller dan het licht; daarom kan de procentuele winst die je meet hoger uitvallen dan in een echt systeem met een laadregelaar. Tel je ook de stromen (V / R) van de twee panelen op en vergelijk je die, dan zie je ook hoe groot het verschil in licht dat ze bereikt echt is.

De vergelijking moet eerlijk zijn. Leg je het vaste paneel plat op een tafel of richt je het de verkeerde kant op, dan lijkt de tracker veel beter dan hij echt is en ziet de jury dat bij de eerste vraag. Het vaste paneel moet precies op het zuiden staan en zijn kanteling moet bij de zon op het middaguur van die dag passen: kanteling = 90° − elevatie op het middaguur. Als vuistregel werkt breedtegraad + 10–15° goed in herfst en winter, breedtegraad − 10–15° in lente en zomer. Op het lokale zonnige middaguur wijst de schaduw van een verticale stok precies naar het noorden; zo vind je het zuiden het makkelijkst.

Energiebalans: kan het systeem zichzelf van stroom voorzien?

Dit is de lievelingsvraag van de jury. Een tracker wint energie, maar gebruikt er ook wat. Voor een minimodel zien de grove getallen er zo uit:

OnderdeelBij benaderingDagelijkse energie
Arduino Uno (altijd aan)45–50 mA, ongeveer 0,25 W bij 5 VOngeveer 6 Wh (24 uur)
2 × SG90 (stilstaand)Een paar mA tot 10 mA per servoOngeveer 1–2,5 Wh (24 uur)
SG90 (bewegend)100–250 mA, kortstondigHangt af van hoe vaak hij corrigeert, meestal klein
ESP32 (Wi-Fi aan)Gemiddeld 80–150 mAOngeveer 10–18 Wh (24 uur)
Mini-paneel 6 V 1 W (heldere dag)Hooguit 1 WOngeveer 3–5 Wh geproduceerd

De tabel maakt het duidelijk: een minimodel kan niet genoeg energie opwekken om zijn eigen elektronica te laten draaien. De extra 1–1,5 Wh die volgen oplevert, is klein naast de ongeveer 6 Wh die de Uno per dag gebruikt. Dat is geen mislukking; het is een eerlijk en waardevol resultaat. Naarmate de schaal groeit, draait het beeld om: het verbruik van de motor en regelaar die panelen ter grootte van kilowatts draaien, is dan een klein deel van de opbrengst. Om het verbruik van een minisysteem te verlagen, corrigeer je één keer per minuut, laat je de servo's met detach() los als ze niet bewegen en kies je in plaats van de Uno een Pro Mini die kan slapen of een ESP32 met deep sleep. Om de looptijd van een batterij in te schatten, gebruik je de batterijduur-calculator en de gids mAh en Wh.

Zonvolgen met de ESP32 en meekijken vanaf je telefoon

ESP32-ontwikkelboard
ESP32: dankzij de ADC van 12 bit en Wi-Fi kan hij zowel het paneel draaien als de metingen naar je telefoon sturen.

De ESP32 draait dezelfde logica met een fijnere ADC en Wi-Fi. Er zijn een paar verschillen om op te letten. De analoge waarden lopen van 0 tot 4095, dus de dode zone is ongeveer 4 keer die van de Uno. Met Wi-Fi aan werken alleen de ADC1-pinnen (GPIO 32–39) betrouwbaar, omdat de ADC2-pinnen door de Wi-Fi-driver worden gebruikt. Installeer voor de servo's de bibliotheek ESP32Servo via de Library Manager. De functie analogReadMilliVolts() waarmee je de paneelspanning meet, corrigeert het niet-lineaire gedrag van de ADC van de ESP32 met de fabriekskalibratie. Voed de LDR-delers altijd met 3V3. Open na het uploaden het IP-adres dat in de Serial Monitor staat op een telefoon die met hetzelfde netwerk verbonden is en je ziet de live spanning van beide panelen, de verzamelde energie en de winst. Ben je nieuw met de ESP32, begin dan met Wat is de ESP32?.

C++ (Arduino IDE)
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}

Wil je de metingen dagenlang bewaren, dan kun je dezelfde waarden naar een online spreadsheet sturen; zie ESP32-gegevens loggen in Google Sheets. Meer over ADC-resolutie en referentiespanning vind je in ADC en analoog-digitaalomzetting.

Volgen met één as met Raspberry Pi Pico en MicroPython

Raspberry Pi Pico
Raspberry Pi Pico: zijn drie beschikbare ADC-pinnen (GP26, GP27, GP28) volstaan voor een tracker met één as plus één paneelmeting.

De Pico heeft maar drie analoge ingangen (GP26, GP27, GP28), wat niet genoeg is voor vier LDR's en twee panelen. Daarom is de nettste oplossing voor de Pico een tracker met één as: twee LDR's vinden de richting en de derde analoge ingang meet de paneelspanning. Voor twee assen kun je een externe I2C-ADC toevoegen, zoals de ADS1115 met 4 kanalen. De servo wordt rechtstreeks aangestuurd met 50 Hz PWM: een puls van 500 µs betekent 0°, een puls van 2400 µs 180°. Omdat read_u16() waarden op een schaal van 0–65535 geeft, is de dode zone een groot getal zoals 2000. Hoe je MicroPython op de Pico installeert, vind je in Wat is de Raspberry Pi Pico?.

MicroPython
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)

De code voegt de metingen toe aan een bestand log.csv in het eigen flashgeheugen van de Pico. Eén regel per minuut komt neer op 30–40 KB per dag, dus het bestandssysteem van ongeveer 1,4 MB van de Pico gaat weken mee. Sla je het bestand op als main.py, dan start de Pico het programma zelf zodra hij van stroom wordt voorzien via een batterij of USB-adapter, zonder computer. Aan het eind van de dag kun je log.csv met Thonny naar je computer downloaden en in Excel openen.

Tips voor presenteren op een wetenschapsbeurs

De solartracker is een veelvoorkomend project op wetenschapsbeurzen en schoolwedstrijden; wat het jouwe laat opvallen is niet het model zelf, maar je gemeten gegevens en hoe je die interpreteert. Voor projectideeën en de opbouw van je verslag kun je ook Arduino-projectideeën voor wetenschapsbeurzen bekijken.

  • Stel een meetbare vraag: Hoeveel procent meer energie vangt een tracker met twee assen op een heldere herfstdag dan een identiek paneel dat onder de beste hoek naar het zuiden vastligt?
  • Schrijf eerst je hypothese op: Voorspel bijvoorbeeld dat de winst zich in de ochtend en avond concentreert; ook als het resultaat dat niet bevestigt, levert bespreken waarom punten op.
  • Scheid de variabelen: De onafhankelijke variabele is de volgmethode (geen, één as, twee assen), de afhankelijke variabele is de dagelijkse energie (Wh) en de constant gehouden variabelen zijn paneelmodel, belastingsweerstand, locatie en datum.
  • Vertel het met grafieken: Een lijngrafiek van tijd en vermogen toont beide panelen over elkaar; vergelijk de dagelijkse energie met een staafdiagram en toon de spreiding tussen dagen als je foutmarge.
  • Bespreek de nettoenergie: Meet het eigen verbruik van het systeem en zet de tabel van de energiebalans op je poster; dat laat zien dat het project eerlijk en wetenschappelijk is.
  • In de beurshal is geen zon: Doe de live demo met een zaklamp of spot en neem een timelapse-video van het buitenexperiment en het ruwe CSV-bestand mee.
  • Structureer de poster: Probleem, methode, schakelschema, stroomdiagram van de code, resultaten, beperkingen en suggesties; in elk onderdeel korte zinnen en grote grafieken.
  • Noem zelf de beperkingen: Beperkingen zoals het kleine paneel, maar een paar dagen aan gegevens, wind en LDR-verschillen noemen voordat de jury ernaar vraagt, wekt vertrouwen.
Vraag die de jury kan stellenAntwoord om voor te bereiden
Waarom heb je LDR's gebruikt in plaats van volgen op een klok?Leg uit dat volgen op een klok ook onder wolken werkt maar locatie- en tijdinstellingen nodig heeft, terwijl volgen met LDR's makkelijk in te stellen is en zijn eigen fouten corrigeert maar onder wolken instabiel is.
Dekt het systeem de energie die het gebruikt?Antwoord met je tabel van de energiebalans: niet in een minisysteem, maar naarmate de schaal groeit, wordt het verbruik een klein deel van de opbrengst.
Hoe heb je het vaste paneel gericht?Precies op het zuiden, met de beste kanteling voor de zon op het middaguur van die dag; laat zien dat je in een voortest ook het verschil tussen de twee panelen hebt gemeten.
Wat gebeurt er op een bewolkte dag?Omdat het licht diffuus is, zakt de winst naar bijna nul; de dode zone voorkomt dat het paneel voor niets beweegt. Laat je gegevens van een bewolkte dag zien.
Worden trackers in echte zonneparken gebruikt?Ja; volgen met één as is gebruikelijk in grote zonneparken. Systemen met twee assen kosten meer en vragen meer onderhoud.
Hoe heb je de meetfout verkleind?Beschrijf het middelen van acht metingen, het kalibreren met een multimeter, het omwisselen van de panelen en het herhalen van het experiment over meerdere dagen.

Veelvoorkomende fouten en oplossingen

ProbleemWaarschijnlijke oorzaakOplossing
Het paneel draait van het licht wegDe servorichting is omgekeerd voor jouw montageZet DIR_H of DIR_V op -1
De servo trilt naar links en rechtsDode zone te smal, ruisige metingenVerhoog TOL_START en TOL_STOP, middel meer metingen
Het paneel stopt iets naast de zonLDR's niet gekalibreerd of sensor niet evenwijdig aan het paneelKalibreer en lijn het sensorblok uit met het paneeloppervlak
De Arduino reset als de servo beweegtDe servo's worden gevoed via de 5V-pin van het boardGebruik een externe 5 V-voeding, een gemeenschappelijke GND en een condensator van 470 µF
In de zon zijn alle vier de waarden bijna 1000, geen verschilVaste weerstand te groot, waarden raken verzadigdGebruik buiten 1–2,2 kΩ en maak de schaduwwand hoger
Beide panelen tonen 7 V, geen zichtbaar verschilGeen belastingsweerstand, je meet de nullastspanningSluit op elk paneel een belastingsweerstand van 33 Ω aan
Op de ESP32 raken analoge waarden verstoord als Wi-Fi startDe LDR's zitten op ADC2-pinnenGebruik de ADC1-pinnen tussen GPIO 32 en 39
Het paneel blijft 's avonds naar het westen staan en draait 's ochtends laatDe nachtstand komt niet overeen met je montage, of NIGHT is te laagZet H_PARK op het oostelijke uiteinde van je montage (180 of 0); ligt het gemiddelde 's nachts boven NIGHT, verhoog dan de drempel
Op bewolkte dagen dwaalt het paneel willekeurig rondIn diffuus licht is het verschil klein en instabielMaak de dode zone breder en stop met bewegen bij weinig licht door de drempel NIGHT te verhogen
Upload bij het oplossen van problemen eerst opnieuw de kalibratiecode en kijk naar de vier LDR's in de Serial Plotter. Werkt de sensor goed, dan zit het probleem in de mechanica of de voeding; zijn de sensorwaarden inconsistent, controleer dan de draden, de weerstanden en de schaduwwand.

Ideeën om het project verder uit te bouwen

  • Zonnelaadstation: Sluit het volgende paneel aan op een TP4056-oplaadmodule en een 18650-cel en vergelijk de laadtijd met het vaste paneel.
  • Hybride volgen: Bereken de positie van de zon met een RTC-klokmodule en gebruik de LDR's alleen voor de fijnafstelling; het paneel wijst ook op bewolkte dagen de goede kant op.
  • Wi-Fi-datalogging: Stuur de metingen van de ESP32 naar Google Sheets en bekijk de grafiek live op je telefoon.
  • Kas op zonne-energie: Gebruik het volgende paneel om de ventilator en bewatering van een model van een slimme kas van stroom te voorzien.
  • Lichtscanner: Bouw een versie die één LDR met een servo van 0 tot 180° laat zwaaien en de helderste richting vindt; de logica lijkt sterk op het Arduino-radarproject.
  • Nauwkeurigere vermogensmeting: Gebruik naast de belastingsweerstand een I2C-vermogenssensor zoals de INA219, die stroom en spanning samen meet, en teken de vermogenscurve van het paneel.

Een solartracker combineert sensoren uitlezen, beslissingen nemen, motoren aansturen en wetenschappelijk meten in één project, waardoor hij een geweldige keuze is om van te leren en om op een wedstrijd te laten zien. Begin met één as, stem de dode zone af en voeg dan de tweede as en het experiment met het vaste paneel toe. In de BlueGrays-app vind je projecten waarmee je elk onderdeel van dit systeem afzonderlijk kunt uitproberen, zoals licht meten met een LDR, een nachtlampje, servohoek regelen en een digitale voltmeter, elk met schakelschema's en code.

Veelgestelde vragen

Hoeveel verhoogt een solartracker de opbrengst?

In grote systemen vangt volgen met één as ongeveer 15–35% meer energie op dan een vast paneel en volgen met twee assen ongeveer 30–45% meer. De winst is het hoogst op heldere dagen en 's ochtends en 's avonds als de zon laag staat, en ligt rond het middaguur dicht bij nul. Om de echte waarde voor je eigen opstelling te weten, meet je die op dezelfde dag tegen een identiek vast paneel.

Hoeveel LDR's heeft een solartracker nodig?

Twee LDR's zijn genoeg voor een tracker met één as en vier voor een met twee assen. Tussen de LDR's zit een schaduwwand; beweegt de zon naar één kant, dan beschaduwt de wand de LDR's aan de tegenovergestelde kant en draait de Arduino het paneel op basis van het verschil. Meer LDR's gebruiken verbetert de nauwkeurigheid niet merkbaar.

Moet ik een solartracker met één as of met twee assen bouwen?

Is het je eerste project, begin dan met één as: één servo en twee LDR's geven je het grootste deel van de winst met eenvoudige mechanica. Twee assen vangen iets meer energie op en maken meer indruk op wetenschapsbeurzen, maar vragen een pan-tilthouder en het samen afstemmen van twee assen.

Welke servo moet ik voor een solartracker gebruiken?

Een SG90 is genoeg voor lichte mini-panelen zoals een model van 6 V en 1 W; buiten in de wind is de MG90S met metalen tandwielen duurzamer. Grotere panelen van 5 W en meer hebben een servo met veel koppel nodig, zoals de MG996R, of een motor met tandwielkast. Voed de servo's altijd met een externe 5 V-voeding en verbind de massa's met elkaar.

Waarom trilt de servo in mijn solartracker?

LDR-waarden schommelen door ruis voortdurend een paar tellen; zonder dode zone (tolerantie) in de code beweegt de servo bij elk klein verschil heen en weer. Een dode zone die verschillen onder een grens negeert, of zelfs twee aparte grenzen voor starten en stoppen (hysterese), maakt een eind aan het getril. Ook een zwakke servovoeding kan het veroorzaken.

Kan een solartracker zichzelf van stroom voorzien?

Als minimodel niet: een Arduino Uno gebruikt ongeveer 6 Wh per dag, terwijl een paneel van 6 V en 1 W op een heldere dag 3–5 Wh produceert. In grote systemen gebruiken de motor en regelaar echter maar een klein deel van de opbrengst. Deze berekening in je verslag laten zien maakt het project wetenschappelijk sterker.

Alle projecten bekijken
Lichtsterkte meten met een LDR
AR-11Beginner

Lichtsterkte meten met een LDR

Wil je zien hoe licht je kamer is, als getal? De LDR, een klein onderdeel dat op licht reageert, meet het licht om je heen en de Arduino schrijft de waarde elke halve seconde naar je computerscherm.

4.6(83)
143
Nachtlampje met LDR
AR-12Beginner

Nachtlampje met LDR

Een klein nachtlampje dat vanzelf aangaat als het donker wordt en uitgaat als het ochtend is.

4.7(105)
224
Lichtsterkte meten met de ESP32 en een LDR-module
ES-11Beginner

Lichtsterkte meten met de ESP32 en een LDR-module

Volg in de Serial Monitor in realtime de ruwe ADC-waarde van de LDR-module en het relatieve lichtpercentage, berekend uit referentiewaarden voor donker en licht. Dit percentage is geen luxmeting. Je leert hoe de module gekalibreerd wordt. Ideaal om vóór Project 10 te doen, want je gebruikt het om de drempelwaarde te bepalen.

4.6(36)
55
Een servomotor gebruiken
AR-35Beginner
Premium

Een servomotor gebruiken

De arm van een kleine servomotor draait na elkaar naar drie standen: helemaal naar het begin, precies naar het midden en helemaal naar het einde, en wacht bij elke stop twee seconden.

4.7(48)
67
ESP32-servomotor (bediening met potentiometer)
ES-16Gemiddeld
Premium

ESP32-servomotor (bediening met potentiometer)

In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

4.3(29)
42
Digitale voltmeter met lcd-scherm
AR-56Gemiddeld
Premium

Digitale voltmeter met lcd-scherm

Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

4.5(27)
36
ESP32-nachtlampje met LDR
ES-10Beginner
Premium

ESP32-nachtlampje met LDR

Nachtlampje waarvan de LED in het donker automatisch aangaat en bij licht uit. Je gebruikt de D0-pin (digitale uitgang) van de LDR-sensormodule: de donkerdrempel stel je in met de kleine potmeter op de module en de module zelf geeft het HIGH/LOW-signaal. De ESP32 leest dit signaal alleen met digitalRead(); de code is heel eenvoudig.

4.6(17)
30