Inseguitore solare Arduino: 2 assi con 4 LDR, servo e misure

Un inseguitore solare con Arduino (in inglese solar tracker) è un meccanismo automatico che tiene un pannello solare rivolto verso il sole per tutto il giorno: dei sensori misurano da dove arriva la luce e un motore orienta il pannello in quella direzione. Un tipico progetto Arduino usa quattro LDR (fotoresistenze) e due servomotori. Le LDR dicono alla scheda quale lato è più illuminato e i servo girano il pannello verso quel lato. Un pannello fisso vede il sole di lato al mattino e alla sera e spreca buona parte dell'energia disponibile, mentre un pannello a inseguimento riceve la luce quasi ad angolo retto a ogni ora del giorno.

In questa guida imparerai passo passo la differenza tra inseguimento monoassiale e biassiale, come si calcola la differenza di luce con 4 LDR, la logica della zona morta (tolleranza) che impedisce al servo di vibrare inutilmente e la struttura meccanica che sostiene il pannello. Oltre al codice pronto da compilare per Arduino Uno, ESP32 e Raspberry Pi Pico, troverai un esperimento che misura davvero il guadagno di energia confrontando il pannello a inseguimento con uno fisso, la lista dei componenti e consigli per presentare il progetto a una fiera della scienza.

Che cos'è un inseguitore solare e perché aumenta la produzione?

La potenza prodotta da un pannello dipende dall'angolo con cui la luce colpisce la sua superficie. Quando la luce arriva perpendicolare, il pannello ne cattura il massimo; più arriva inclinata, più lo stesso fascio si distribuisce su una superficie ampia e l'irraggiamento ricevuto cala secondo il coseno dell'angolo di incidenza. Per questo la luce che arriva a 60° dalla perpendicolare produce solo metà della potenza della luce che colpisce il pannello di fronte. La tabella qui sotto mostra questa perdita. Guardandola bene noterai anche che i piccoli errori non costano quasi nulla: un pannello che manca il sole di 5° perde solo lo 0,4% della potenza. Ti servirà più avanti per scegliere la zona morta.

La posizione del sole nel cielo si descrive con due angoli: l'azimut, che indica in quale direzione dell'orizzonte si trova, e l'altezza (elevazione), che indica quanto è alto sopra l'orizzonte. Poiché la Terra ruota di 15° all'ora, il sole si sposta in media di circa 1° ogni 4 minuti, mentre la sua altezza cambia molto con le stagioni. La tabella vale per circa 39° nord (la latitudine di Cagliari); a Roma, a circa 42° nord, il sole di mezzogiorno è più basso di circa 3°.

L'azimut si misura dal nord in senso orario. Dalla tabella seguono due conclusioni importanti. D'estate il sole sorge a nord-est e tramonta a nord-ovest, percorrendo circa 240° durante la giornata; un servo che ruota di 180° non riesce a girarsi del tutto verso il sole nelle prime e nelle ultime ore, ma la perdita è piccola perché in quei momenti il sole è basso e debole. D'inverno il sole resta basso anche a mezzogiorno, quindi un pannello fisso esposto a sud avrebbe bisogno di un'inclinazione diversa per ogni stagione. Un inseguitore risolve entrambi i problemi da solo.

Monoassiale o biassiale?

Un inseguitore monoassiale segue solo il movimento del sole da est a ovest; la sua inclinazione è fissa e regolata in base alla stagione. Questo asse porta la maggior parte del guadagno, perché il più grande spostamento quotidiano del sole avviene da est a ovest. Anche nei grandi impianti fotovoltaici è il tipo più diffuso; i sistemi biassiali raccolgono un po' più di energia, ma costano di più e richiedono più manutenzione. Per un progetto scolastico, invece, i due assi offrono una dimostrazione più spettacolare e un bel problema per imparare a controllare due assi insieme.

Misurare la differenza di luce: 4 LDR e una parete d'ombra

Una sola LDR ti dice soltanto quanta luce c'è; per trovare una direzione devi confrontare almeno due LDR. In un inseguitore biassiale le quattro LDR formano un quadrato 2×2, separate da un divisorio opaco a forma di croce (+): la parete d'ombra. Quando il sensore punta dritto al sole, la parete non fa ombra su nessuna LDR e tutte e quattro vedono la stessa luce. Quando il sole si sposta da un lato, la parete ombreggia le LDR del lato opposto e i loro valori scendono. L'altezza della parete stabilisce la sensibilità: una parete di 3 cm, con uno scostamento di 5°, proietta un'ombra larga circa 2,6 mm (3 cm × tan 5°), sufficiente a coprire metà di una LDR da 5 mm. Una parete alta dà un sensore più sensibile ma con angolo più stretto, una bassa un sensore più grossolano ma con angolo più ampio. Per vedere nel dettaglio come funziona una LDR, leggi sensore di luce LDR.

• Media superiore: (in alto a sinistra + in alto a destra) / 2
• Media inferiore: (in basso a sinistra + in basso a destra) / 2
• Media sinistra: (in alto a sinistra + in basso a sinistra) / 2
• Media destra: (in alto a destra + in basso a destra) / 2
• Differenza verticale (dV): alto − basso. Se è positiva il pannello deve inclinarsi verso l'alto, se è negativa verso il basso.
• Differenza orizzontale (dH): sinistra − destra. Se è positiva il pannello deve girare a sinistra, se è negativa a destra.

Inseguimento con sensori o con orologio?

L'inseguimento con LDR non è l'unico metodo. Poiché la posizione del sole si può calcolare in anticipo a partire da data, ora e luogo, alcuni sistemi non usano alcun sensore di luce. Confrontiamo i tre approcci:

In questa guida costruiamo la versione con sensori, perché non richiede posizione né ora, è facile da mettere in funzione e corregge da sola gli errori meccanici. Se vuoi ampliare il progetto, aggiungere in seguito l'inseguimento a orologio con un modulo RTC e confrontare i due metodi è un esperimento extra molto convincente davanti alla giuria.

Lista dei componenti

Collegamenti: Arduino Uno, ESP32 e Pico

Un piedino di ogni LDR va all'alimentazione (5V sull'Uno, 3V3 su ESP32 e Pico) e l'altro a un pin analogico; dallo stesso pin analogico parte una resistenza fissa verso GND. Così il valore letto sale quando aumenta la luce. Sul lato dei pannelli, tra i due terminali di ogni pannello si collega una resistenza di carico (33 Ω). La tensione del pannello viene divisa per 3,2 con un partitore da 22 kΩ e 10 kΩ prima di arrivare al pin analogico: 22 kΩ dal positivo del pannello al pin analogico, 10 kΩ dal pin analogico a GND. Anche il negativo del pannello deve andare al GND della scheda; senza massa comune la misura non ha senso.

Meccanica: staffa pan-tilt ed equilibrio del pannello

La soluzione meccanica più semplice è una staffa pan-tilt già pronta che porta due servo SG90 uno sopra l'altro: il servo in basso ruota il pannello in orizzontale (est–ovest), quello in alto lo inclina in verticale. Fissa il blocco sensori sul bordo del pannello in modo che la sua superficie sia perfettamente parallela a quella del pannello. Se il sensore guarda in una direzione diversa dal pannello, il sistema segue il sole alla perfezione ma il pannello punta sempre qualche grado di lato. Un mini pannello 6 V 1 W da 110×60 mm pesa circa 22 g; a 3 cm dall'asse corrispondono a circa 0,07 kg·cm di coppia, molto al di sotto degli 1,8 kg·cm dell'SG90. Il vero carico è il vento: se fai le prove all'aperto, centra il pannello sull'asse del servo, usa l'MG90S con ingranaggi in metallo e, con pannelli più grandi, passa a un servo potente come l'MG996R. Lascia ai cavi un'ansa morbida per la rotazione; un cavo teso sforza il servo e strappa i collegamenti. Per le basi sui servo leggi cos'è un servomotore.

Montaggio passo passo

1. Salda le quattro LDR su un pezzo di millefori formando un quadrato 2×2 e incolla tra loro un divisorio a croce alto 2–3 cm, in cartone o stampato in 3D; dipingilo di nero opaco o coprilo con nastro nero.
2. Monta il partitore di ogni LDR: la LDR dall'alimentazione al pin analogico, la resistenza fissa dal pin analogico a GND.
3. Inserisci i servo nella staffa pan-tilt, portali entrambi a 90° e avvita le squadrette in posizione centrale.
4. Fissa il pannello e il blocco sensori sulla staffa superiore con le superfici parallele.
5. Monta il circuito di misura del pannello: resistenza di carico tra i terminali del pannello, partitore tra il positivo del pannello e GND, punto centrale su A4.
6. Alimenta i servo con la sorgente esterna da 5 V, unisci tutti i GND e collega il condensatore da 470 µF in parallelo all'alimentazione dei servo.
7. Carica prima il codice di calibrazione, poi quello di inseguimento, e prova il sistema con una torcia.

Passo 1: prova e calibra le LDR

Anche le LDR dello stesso sacchetto danno valori nettamente diversi con la stessa luce; il datasheet della GL5528 indica un intervallo ampio come 10–20 kΩ a 10 lux. Un sensore non calibrato crede che un lato sia più illuminato anche quando punta dritto al sole, e gira il pannello di qualche grado nella direzione sbagliata. Carica il codice qui sotto, apri il Plotter seriale dal menu Strumenti e illumina il blocco sensori in modo uniforme; per esempio un foglio di carta bianca teso davanti a una lampada diffonde e uniforma bene la luce.

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}

Con la stessa luce le quattro linee dovrebbero stare allo stesso livello. Supponiamo che i valori siano 612, 640, 598 e 625; la media è 619. La correzione di ogni LDR è la media meno il suo valore: +7, −21, +21 e −6. Questi numeri vanno nell'array OFFSET del codice del passo 3. Poiché la resistenza di una LDR non varia in modo lineare con la luce, calibrare con un livello di luce vicino a quello d'uso reale dà il risultato più preciso. Nel Plotter seriale vedi anche il rumore: annota di quante unità oscillano i valori senza che tu tocchi nulla, perché ti servirà per scegliere la zona morta.

Passo 2: codice dell'inseguitore solare monoassiale

Vediamo prima la logica su un solo asse. Due LDR, separate da una parete d'ombra verticale, guardano verso est e verso ovest: A0 è la LDR est e A1 la LDR ovest. Il codice sottrae un valore dall'altro; se la differenza supera la zona morta, il servo ruota di 1° verso il lato più illuminato, altrimenti resta fermo. Questo breve sketch è già un inseguitore monoassiale completo. Se il pannello scappa dalla luce, scambia angle++ e angle-- nelle due condizioni.

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}

Con delay(30) il servo ruota al massimo di 1° ogni 30 ms, cioè circa 33° al secondo, quindi durante una dimostrazione il pannello segue senza problemi una torcia. Il sole si muove molto più lentamente, perciò nell'uso reale basta una correzione ogni pochi secondi.

Passo 3: codice biassiale, zona morta e registrazione dei dati

La versione completa calcola due differenze dalle quattro LDR, corregge ogni asse separatamente, quando scende la notte parcheggia il pannello pronto per il mattino e una volta al minuto scrive sul Monitor seriale, in formato CSV, la tensione, la potenza e l'energia accumulata dei due pannelli. Il codice usa millis() al posto di delay(), così inseguimento e registrazione girano senza aspettarsi a vicenda. I dettagli sono in millis invece di 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}

Evitare le vibrazioni con una zona morta (tolleranza)

Senza zona morta il sistema non si ferma mai. Anche quando punta dritto al sole, i valori delle LDR oscillano di qualche unità per il rumore, la differenza passa da positiva a negativa e il servo continua a fare 1° a destra, 1° a sinistra. Questa vibrazione consuma gli ingranaggi del servo e spreca energia. La soluzione è ignorare le piccole differenze: se la differenza è sotto un certo limite, non si fa nulla. Per scegliere il limite usa il rumore osservato durante la calibrazione e fai la zona morta almeno 3–4 volte più grande del rumore. Sull'Uno, se il rumore è di circa ±5 unità, 20–40 è un buon punto di partenza.

Il metodo del codice fa un passo in più: l'isteresi. Il servo parte quando la differenza supera 40, ma si ferma solo quando scende sotto 15. Con una zona morta a un solo limite il pannello si ferma proprio sul bordo e una piccola nuvola o una folata lo rimettono in moto; il sistema a due limiti porta ogni volta il pannello ben in direzione del sole e poi si calma. L'effetto della zona morta sull'energia è trascurabile: come mostra la tabella del coseno, pochi gradi di scostamento significano meno dell'1% di perdita. Per altre tecniche di filtraggio leggi filtrare i dati dei sensori.

Esperimento di rendimento: pannello a inseguimento contro pannello fisso

L'unico modo per dimostrare che l'inseguitore funziona è misurarlo. L'errore più comune è misurare solo la tensione a circuito aperto del pannello. La tensione senza carico cambia pochissimo con la luce: quando la luce si dimezza, anche la corrente si dimezza circa, ma la tensione a vuoto cala solo del 3–5%. Così entrambi i pannelli segnano circa 7 V e la differenza sparisce. Il metodo giusto è collegare a ogni pannello la stessa resistenza di carico e misurare la tensione ai suoi capi. La potenza si ricava con P = V² / R e l'energia sommando la potenza nel tempo. Scegli la resistenza di carico in base al punto di massima potenza del pannello: un pannello 6 V 1 W eroga circa 1 / 6 = 0,17 A, quindi la resistenza adatta è 6 / 0,17 ≈ 36 Ω; un valore standard da 33 Ω è un'ottima scelta. Poiché la resistenza dissipa quasi 1 W in calore, usane una da almeno 2 W, meglio una ceramica da 5 W. Puoi verificare i conti con il calcolatore della legge di Ohm.

1. Usa due pannelli identici: stesso modello e, se possibile, stesso lotto. Collega a entrambi una resistenza di carico da 33 Ω e un partitore 22 kΩ / 10 kΩ; il pannello a inseguimento va su A4, quello fisso su A5.
2. Fai una prova preliminare: fissa i due pannelli uno accanto all'altro con lo stesso orientamento e la stessa inclinazione e misura per 30–60 minuti. Annota la differenza (per esempio il 2%) e correggi i risultati di conseguenza. Ancora meglio, il secondo giorno scambia i pannelli.
3. Orienta il pannello fisso esattamente a sud e regola l'inclinazione sul sole di mezzogiorno di quel giorno (vedi l'avviso più sotto).
4. Distanzia i pannelli abbastanza perché nessuno faccia ombra all'altro o al sensore, in un punto senza ombre di alberi o muri.
5. Misura una volta la tensione del pannello con un multimetro e confrontala con la lettura di Arduino; se non coincidono, correggi il valore DIVIDER (come usare il multimetro).
6. Registra una volta al minuto dall'alba al tramonto e annota il meteo (sereno, parzialmente nuvoloso, coperto).
7. Ripeti l'esperimento in almeno tre giornate serene, registra a parte una giornata coperta e confronta l'energia media giornaliera.

Puoi copiare i dati dal Monitor seriale e salvarli come file CSV oppure inviarli direttamente a Excel (esportare i dati di Arduino in Excel); se non vuoi restare accanto al computer, aggiungi un modulo scheda SD. Nel grafico di una giornata serena la linea del pannello a inseguimento resta nettamente più alta al mattino e alla sera, mentre verso mezzogiorno le due linee quasi si sovrappongono. Per i grandi impianti si riportano guadagni di energia di circa il 15–35% con un asse e del 30–45% con due assi; con un piccolo montaggio il risultato dipende molto dal meteo, dalla stagione e da quanto bene è orientato il pannello fisso. Scrivi chiaramente nella relazione che non hai misurato il rendimento del pannello, ma l'aumento di energia raccolta dallo stesso pannello. Aggiungi anche un limite: su una resistenza di carico fissa la potenza varia con il quadrato della corrente, quindi quando la luce si indebolisce la potenza del pannello cala più in fretta della luce; per questo il guadagno percentuale che misuri può risultare più alto che in un impianto reale con regolatore di carica. Se sommi e confronti anche le correnti dei due pannelli (V / R), vedrai anche la differenza reale di luce che ricevono.

Bilancio energetico: il sistema può alimentarsi da solo?

È la domanda preferita delle giurie. Un inseguitore fa guadagnare energia, ma ne consuma anche. Per un piccolo modellino il calcolo approssimativo è questo:

La tabella parla chiaro: un piccolo modellino non produce abbastanza energia per far funzionare la propria elettronica. I circa 1–1,5 Wh in più ottenuti con l'inseguimento sono poca cosa rispetto ai circa 6 Wh che l'Uno consuma al giorno. Non è un fallimento, ma un risultato onesto e prezioso. Quando la scala cresce la situazione si ribalta: il consumo del motore e del controllore che orientano pannelli da kilowatt diventa una piccola frazione della produzione. Per ridurre i consumi in un piccolo sistema, correggi una volta al minuto, rilascia i servo con detach() quando non si muovono e al posto dell'Uno scegli un Pro Mini che va in sospensione o un ESP32 con il deep sleep. Per stimare l'autonomia a batteria usa il calcolatore di durata della batteria e la guida su mAh e Wh.

Inseguitore solare con ESP32 e controllo dallo smartphone

L'ESP32 esegue la stessa logica con un ADC più fine e il Wi-Fi. Ci sono alcune differenze da tenere presenti. I valori analogici vanno da 0 a 4095, quindi la zona morta è circa 4 volte quella dell'Uno. Con il Wi-Fi attivo funzionano in modo affidabile solo i pin ADC1 (GPIO 32–39), perché i pin ADC2 sono usati dal Wi-Fi. Per i servo installa la libreria ESP32Servo dal Gestore librerie. La funzione analogReadMilliVolts(), usata per misurare la tensione del pannello, corregge il comportamento non lineare dell'ADC dell'ESP32 con la calibrazione di fabbrica. Alimenta sempre i partitori delle LDR dal 3V3. Dopo il caricamento, apri su uno smartphone collegato alla stessa rete l'indirizzo IP mostrato nel Monitor seriale: vedrai in tempo reale la tensione dei due pannelli, l'energia accumulata e il guadagno. Se sei alle prime armi con l'ESP32, parti da cos'è l'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}

Se vuoi conservare le misure per giorni, puoi inviare gli stessi valori a un foglio di calcolo online; vedi salvare i dati dell'ESP32 su Google Fogli. Trovi di più sulla risoluzione dell'ADC e sulla tensione di riferimento in ADC e conversione analogico-digitale.

Inseguimento monoassiale con Raspberry Pi Pico e MicroPython

Il Pico ha solo tre ingressi analogici accessibili (GP26, GP27, GP28), troppo pochi per quattro LDR e due pannelli. Per questo la soluzione più pulita con il Pico è un inseguitore monoassiale: due LDR trovano la direzione e il terzo ingresso analogico misura la tensione del pannello. Se vuoi due assi puoi aggiungere un ADC esterno I2C come l'ADS1115 a 4 canali. Il servo si pilota direttamente con un PWM a 50 Hz: un impulso di 500 µs corrisponde a 0°, uno di 2400 µs a 180°. Poiché read_u16() restituisce valori su una scala da 0 a 65535, la zona morta è un numero grande come 2000. Per installare MicroPython sul Pico leggi cos'è il 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)

Il codice aggiunge le misure al file log.csv nella memoria flash del Pico. Una riga al minuto fa 30–40 KB al giorno, quindi il file system di circa 1,4 MB del Pico basta per settimane. Se salvi il file con il nome main.py, il Pico avvia il programma da solo appena riceve alimentazione da una batteria o da un alimentatore USB, senza computer. A fine giornata puoi scaricare log.csv sul computer con Thonny e aprirlo in Excel.

Consigli per la fiera della scienza

L'inseguitore solare è un progetto frequente alle fiere della scienza e ai concorsi scolastici; a far risaltare il tuo non sarà il modellino, ma i tuoi dati misurati e il modo in cui li interpreti. Per idee e per la struttura della relazione guarda anche progetti Arduino per la scuola.

• Fai una domanda misurabile: Di quanto per cento un inseguimento biassiale raccoglie più energia, in una giornata serena d'autunno, rispetto a un pannello identico fissato a sud con l'angolo migliore?
• Scrivi prima l'ipotesi: Per esempio prevedi che il guadagno si concentrerà al mattino e alla sera; anche se il risultato non la conferma, discuterlo fa guadagnare punti.
• Separa le variabili: La variabile indipendente è il metodo di inseguimento (nessuno, un asse, due assi), quella dipendente l'energia giornaliera (Wh), quelle controllate il modello di pannello, la resistenza di carico, il luogo e la data.
• Racconta con i grafici: Un grafico a linee ora–potenza mostra i due pannelli sovrapposti; confronta l'energia giornaliera con un istogramma e indica la differenza tra i giorni come margine di errore.
• Parla di energia netta: Misura il consumo del sistema e metti sul poster la tabella del bilancio energetico; dimostra che il progetto è onesto e scientifico.
• Nella sala della fiera non c'è il sole: Fai la dimostrazione dal vivo con una torcia o un faretto e porta un video in time-lapse dell'esperimento all'aperto e il file CSV originale.
• Organizza il poster: Problema, metodo, schema del circuito, diagramma di flusso del codice, risultati, limiti e proposte; frasi brevi e grafici grandi in ogni sezione.
• Dichiara tu i limiti: Citare il pannello piccolo, i pochi giorni di dati, il vento e le differenze tra LDR prima che lo chieda la giuria ispira fiducia.

Errori comuni e soluzioni

Idee per sviluppare il progetto

• Stazione di ricarica solare: Collega il pannello a inseguimento a un modulo di ricarica TP4056 e a una cella 18650 e confronta il tempo di ricarica con quello del pannello fisso.
• Inseguimento ibrido: Calcola la posizione del sole con un modulo orologio RTC e usa le LDR solo per rifinire; il pannello punta bene anche nelle giornate nuvolose.
• Registrazione via Wi-Fi: Invia le misure dall'ESP32 a Google Fogli e segui il grafico dal vivo sullo smartphone.
• Serra a energia solare: Usa il pannello a inseguimento per alimentare la ventola e l'irrigazione di un modellino di serra intelligente.
• Scanner di luce: Realizza una versione che fa spazzare a un servo una sola LDR da 0 a 180° e trova la direzione più luminosa; la logica è molto simile al progetto radar con Arduino.
• Misura di potenza più precisa: Accanto alla resistenza di carico usa un sensore di potenza I2C come l'INA219, che misura insieme corrente e tensione, e traccia la curva di potenza del pannello.

Un inseguitore solare riunisce in un solo progetto la lettura dei sensori, le decisioni, il controllo dei motori e la misura scientifica: è quindi una scelta ottima sia per imparare sia per presentarsi a un concorso. Parti da un asse, regola la zona morta e poi aggiungi il secondo asse e l'esperimento con il pannello fisso. Nell'app BlueGrays trovi progetti per provare separatamente ogni parte di questo sistema, come misurare la luce con una LDR, una luce notturna, il controllo dell'angolo di un servo e un voltmetro digitale, con schemi e codice.