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.

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,000 | 100% |
| 5° | 0,996 | 99,6% |
| 10° | 0,985 | 98,5% |
| 20° | 0,940 | 94% |
| 30° | 0,866 | 87% |
| 45° | 0,707 | 71% |
| 60° | 0,500 | 50% |
| 75° | 0,259 | 26% |
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:
| Datum | Elevatie op het middaguur | Richting zonsopkomst | Richting zonsondergang | Daglengte |
|---|---|---|---|---|
| 21 juni | Ongeveer 74° | Ongeveer 59° (noordoost) | Ongeveer 301° (noordwest) | Ongeveer 15 uur |
| 21 maart en 23 september | Ongeveer 51° | 90° (precies oost) | 270° (precies west) | Ongeveer 12 uur |
| 21 december | Ongeveer 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?
| Eigenschap | Eén as | Twee assen |
|---|---|---|
| Beweging | Alleen oost–west | Oost–west plus kanteling (omhoog–omlaag) |
| Aantal LDR's | 2 | 4 |
| Aantal servo's | 1 | 2 |
| Winst ten opzichte van een vast paneel (grote systemen) | Ongeveer 15–35% | Ongeveer 30–45% |
| Mechaniek | Eenvoudig en robuust | Pan-tilthouder, meer onderdelen |
| Code | Eén verschil, één beslissing | Twee verschillen, twee assen tegelijk |
| Het meest geschikt voor | Een eerste bouwproject, brugklas | Bovenbouw, 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.
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:
| Methode | Hoe werkt het? | Voordelen | Nadelen |
|---|---|---|---|
| Op sensoren (LDR, gesloten lus) | Meet het lichtverschil en draait naar de helderste kant | Eenvoudig; geen locatie of tijd nodig; corrigeert mechanische fouten vanzelf | Instabiel onder wolken; gevoelig voor reflecties en vuile sensoren |
| Op een klok (astronomisch, open lus) | Berekent de positie van de zon uit datum, tijd en locatie | Wijst ook onder wolken de goede kant op; de beweging is vooraf gepland | Tijd, locatie en montagerichting moeten precies ingesteld zijn; merkt mechanische fouten niet op |
| Hybride | Komt dichtbij door berekening, stemt fijn af met de LDR's | Combineert de sterke punten van beide methoden | Complexere 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
| Onderdeel | Aantal | Opmerking |
|---|---|---|
| Arduino Uno (of Nano) | 1 | Een ESP32 of Raspberry Pi Pico werkt ook |
| LDR (GL5528, 5 mm) | 4 | 2 voor één as |
| Weerstand van 10 kΩ | 6 | 4 voor de LDR-spanningsdelers, 2 voor de paneelspanningsdelers; buiten 1–2,2 kΩ voor de LDR's |
| Weerstand van 22 kΩ | 2 | Spanningsdeler voor het paneel |
| Keramische (cement)weerstand van 33 Ω, 5 W | 2 | Eén belastingsweerstand per paneel |
| Servo SG90 of MG90S | 2 | 1 voor één as; MG90S op winderige plekken |
| Pan-tilthouder voor servo's | 1 | Kant-en-klare kunststof set of 3D-print |
| Mini-zonnepaneel 6 V 1 W (110×60 mm) | 2 | Eén volgt de zon, één is de vaste referentie |
| Condensator van 470 µF 16 V | 1 | Parallel aan de servovoeding |
| 5 V 2 A-adapter of 4×AA NiMH-accu's | 1 | Externe voeding voor de servo's |
| Breadboard en jumperdraden | 1 set | Gaatjesprint voor een permanente bouw |
| Karton, zwarte tape of een 3D-geprinte scheidingswand | 1 | Kruisvormige schaduwwand |




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.
| Aansluiting | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LDR linksboven | A0 | GPIO 32 | GP26 (oost-LDR bij één as) |
| LDR rechtsboven | A1 | GPIO 33 | GP27 (west-LDR bij één as) |
| LDR linksonder | A2 | GPIO 34 | Geen (externe ADC nodig) |
| LDR rechtsonder | A3 | GPIO 35 | Geen (externe ADC nodig) |
| Volgend paneel (midden van de deler) | A4 | GPIO 36 (VP) | GP28 |
| Vast paneel (midden van de deler) | A5 | GPIO 39 (VN) | Geen |
| Signaal horizontale servo | D9 | GPIO 18 | GP15 |
| Signaal verticale servo | D10 | GPIO 19 | Geen (één as) |
| Voeding LDR-delers | 5V | 3V3 | 3V3 |
| Servovoeding | Externe 5 V | Externe 5 V | Externe 5 V |
| Alle GND's (inclusief de minpolen van de panelen) | GND | GND | GND |
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
- 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.
- Bouw de deler voor elke LDR: LDR van de voeding naar de analoge pin, vaste weerstand van de analoge pin naar GND.
- Monteer de servo's in de pan-tilthouder, zet beide op 90° en schroef de servohoorns in de middenstand vast.
- Bevestig het paneel en het sensorblok op de bovenste houder, met de vlakken evenwijdig.
- 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.
- 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.
- 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.
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.
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.
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}| Instelling | Waarde | Wat het doet |
|---|---|---|
| OFFSET | Correcties uit stap 1 | Heft de fabricageverschillen tussen de LDR's op |
| TOL_START / TOL_STOP | 40 / 15 | Dode zone met hysterese: draait als het verschil boven 40 komt, stopt als het onder 15 zakt |
| DIR_H / DIR_V | 1 of -1 | Keert de draairichting om zodat die bij jouw montage past |
| V_MIN / V_MAX | 10 / 90 | Grenzen van de verticale servo; voorkomen dat het paneel tegen de houder stoot |
| NIGHT | 60 | Ligt het gemiddelde van de vier LDR's hieronder, dan geldt het als nacht |
| H_PARK / V_PARK | 180 / 45 | Oostelijke stand waarin het paneel na 10 minuten duisternis wacht; wacht het naar het westen gericht, zet H_PARK dan op 0 |
| DIVIDER / LOAD_OHM | 3.2 / 33 | Om de paneelspanning en het vermogen te berekenen met P = V² / R |
| LOG_MS | 60000 | Logginterval: éé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.
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.
- 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.
- 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.
- 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).
- 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.
- 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).
- Log één keer per minuut van zonsopkomst tot zonsondergang en noteer het weer (helder, half bewolkt, bewolkt).
- Herhaal het experiment op minstens drie heldere dagen, log één bewolkte dag apart en vergelijk de gemiddelde dagelijkse energie.
| Kolom | Betekenis |
|---|---|
| dk | Minuten sinds de start van de Arduino |
| V_takip / V_sabit | Spanning over de belastingsweerstand van het volgende / vaste paneel (V) |
| mW_takip / mW_sabit | Momentaan vermogen: V² / R × 1000 |
| mWh_takip / mWh_sabit | Energie 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.
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:
| Onderdeel | Bij benadering | Dagelijkse energie |
|---|---|---|
| Arduino Uno (altijd aan) | 45–50 mA, ongeveer 0,25 W bij 5 V | Ongeveer 6 Wh (24 uur) |
| 2 × SG90 (stilstaand) | Een paar mA tot 10 mA per servo | Ongeveer 1–2,5 Wh (24 uur) |
| SG90 (bewegend) | 100–250 mA, kortstondig | Hangt af van hoe vaak hij corrigeert, meestal klein |
| ESP32 (Wi-Fi aan) | Gemiddeld 80–150 mA | Ongeveer 10–18 Wh (24 uur) |
| Mini-paneel 6 V 1 W (heldere dag) | Hooguit 1 W | Ongeveer 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

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?.
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

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?.
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 stellen | Antwoord 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
| Probleem | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| Het paneel draait van het licht weg | De servorichting is omgekeerd voor jouw montage | Zet DIR_H of DIR_V op -1 |
| De servo trilt naar links en rechts | Dode zone te smal, ruisige metingen | Verhoog TOL_START en TOL_STOP, middel meer metingen |
| Het paneel stopt iets naast de zon | LDR's niet gekalibreerd of sensor niet evenwijdig aan het paneel | Kalibreer en lijn het sensorblok uit met het paneeloppervlak |
| De Arduino reset als de servo beweegt | De servo's worden gevoed via de 5V-pin van het board | Gebruik 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 verschil | Vaste weerstand te groot, waarden raken verzadigd | Gebruik buiten 1–2,2 kΩ en maak de schaduwwand hoger |
| Beide panelen tonen 7 V, geen zichtbaar verschil | Geen belastingsweerstand, je meet de nullastspanning | Sluit op elk paneel een belastingsweerstand van 33 Ω aan |
| Op de ESP32 raken analoge waarden verstoord als Wi-Fi start | De LDR's zitten op ADC2-pinnen | Gebruik de ADC1-pinnen tussen GPIO 32 en 39 |
| Het paneel blijft 's avonds naar het westen staan en draait 's ochtends laat | De nachtstand komt niet overeen met je montage, of NIGHT is te laag | Zet 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 rond | In diffuus licht is het verschil klein en instabiel | Maak de dode zone breder en stop met bewegen bij weinig licht door de drempel NIGHT te verhogen |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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

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.

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.

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.

Digitale voltmeter met lcd-scherm
Ontdek hoeveel spanning een batterij of voedingsadapter geeft met een meter die je zelf hebt gebouwd.

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.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

