Suiveur solaire Arduino : 2 axes avec 4 LDR, servos et mesures

Un suiveur solaire Arduino (ou tracker solaire) est un mécanisme automatique qui garde un panneau solaire tourné vers le soleil toute la journée : des capteurs mesurent d'où vient la lumière et un moteur oriente le panneau dans cette direction. Un montage Arduino classique utilise quatre LDR (photorésistances) et deux servomoteurs. Les LDR indiquent quel côté est le plus éclairé, et les servos tournent le panneau vers ce côté. Un panneau fixe voit le soleil de biais le matin et le soir et perd une grande partie de l'énergie disponible, alors qu'un panneau suiveur reçoit la lumière presque à angle droit à toute heure de la journée.

Dans ce guide, tu vas apprendre pas à pas la différence entre un suivi à un axe et à deux axes, comment on calcule l'écart de lumière avec 4 LDR, la logique de la zone morte (tolérance) qui empêche le servo de trembler pour rien et la structure mécanique qui porte le panneau. En plus d'un code prêt à compiler pour Arduino Uno, ESP32 et Raspberry Pi Pico, tu trouveras une expérience qui mesure vraiment le gain d'énergie en comparant le panneau suiveur à un panneau fixe, la liste du matériel et des conseils pour présenter le projet à un concours scientifique.

Qu'est-ce qu'un suiveur solaire et pourquoi augmente-t-il la production ?

La puissance produite par un panneau dépend de l'angle sous lequel la lumière frappe sa surface. Quand la lumière arrive perpendiculairement, le panneau en capte le maximum ; plus elle arrive en biais, plus le même faisceau s'étale sur une grande surface et plus l'éclairement reçu baisse, selon le cosinus de l'angle d'incidence. C'est pourquoi une lumière qui arrive à 60° de la perpendiculaire ne produit que la moitié de la puissance d'une lumière reçue de face. Le tableau ci-dessous montre cette perte. En le regardant de près, tu verras aussi que les petites erreurs ne coûtent presque rien : un panneau qui rate le soleil de 5° ne perd que 0,4 % de sa puissance. Tu en auras besoin plus loin pour choisir la zone morte.

La position du soleil dans le ciel se décrit avec deux angles : l'azimut, qui indique dans quelle direction de l'horizon il se trouve, et la hauteur (élévation), qui indique à quelle hauteur il est au-dessus de l'horizon. Comme la Terre tourne de 15° par heure, le soleil se déplace en moyenne d'environ 1° toutes les 4 minutes, tandis que sa hauteur varie beaucoup selon les saisons. Le tableau correspond à environ 39° nord (la latitude de Lisbonne ou de Valence) ; à Paris (environ 49° nord), le soleil de midi monte à environ 65° en juin et seulement 18° en décembre.

L'azimut se mesure depuis le nord dans le sens des aiguilles d'une montre. Le tableau mène à deux conclusions importantes. En été, le soleil se lève au nord-est et se couche au nord-ouest : il parcourt environ 240° dans la journée ; un servo qui tourne sur 180° ne peut pas se tourner complètement vers le soleil pendant les premières et les dernières heures, mais la perte reste faible car le soleil est alors bas et peu puissant. En hiver, le soleil reste bas même à midi : un panneau fixe orienté plein sud aurait besoin d'une inclinaison différente à chaque saison. Un suiveur règle ces deux problèmes tout seul.

Un axe ou deux axes ?

Un suiveur à un axe ne suit que le mouvement est-ouest du soleil ; son inclinaison est fixe et réglée selon la saison. Cet axe apporte l'essentiel du gain, car le plus grand déplacement quotidien du soleil se fait d'est en ouest. C'est aussi le type le plus répandu dans les grandes centrales solaires ; les systèmes à deux axes captent un peu plus d'énergie, mais coûtent plus cher et demandent plus d'entretien. Pour un projet scolaire, en revanche, les deux axes offrent une démonstration plus spectaculaire et un beau problème pour apprendre à piloter deux axes en même temps.

Mesurer l'écart de lumière : 4 LDR et un mur d'ombre

Une seule LDR t'indique seulement si l'endroit est éclairé ; pour trouver une direction, il faut comparer au moins deux LDR. Dans un suiveur à deux axes, les quatre LDR forment un carré de 2×2, séparées par une cloison opaque en forme de croix (+) : le mur d'ombre. Quand le capteur est pile face au soleil, le mur ne projette d'ombre sur aucune LDR et les quatre voient la même lumière. Quand le soleil se décale d'un côté, le mur ombrage les LDR du côté opposé et leurs valeurs baissent. La hauteur du mur fixe la sensibilité : un mur de 3 cm projette, pour un écart de 5°, une ombre d'environ 2,6 mm de large (3 cm × tan 5°), de quoi couvrir la moitié d'une LDR de 5 mm. Un mur haut donne un capteur plus sensible mais à angle plus étroit, un mur bas un capteur plus grossier mais à angle plus large. Pour voir en détail comment fonctionne une LDR, lis capteur de lumière LDR.

• Moyenne du haut : (haut gauche + haut droite) / 2
• Moyenne du bas : (bas gauche + bas droite) / 2
• Moyenne de gauche : (haut gauche + bas gauche) / 2
• Moyenne de droite : (haut droite + bas droite) / 2
• Écart vertical (dV) : haut − bas. S'il est positif, le panneau doit s'incliner vers le haut ; s'il est négatif, vers le bas.
• Écart horizontal (dH) : gauche − droite. S'il est positif, le panneau doit tourner à gauche ; s'il est négatif, à droite.

Suivre le soleil avec des capteurs ou avec une horloge ?

Le suivi par LDR n'est pas la seule méthode. Comme la position du soleil peut se calculer à l'avance à partir de la date, de l'heure et du lieu, certains systèmes n'utilisent aucun capteur de lumière. Comparons les trois approches :

Dans ce guide, on construit la version à capteurs : elle n'a besoin ni de position ni d'heure, elle est facile à mettre en place et corrige seule les erreurs mécaniques. Si tu veux aller plus loin, ajouter plus tard un suivi par horloge avec un module RTC et comparer les deux méthodes constitue une expérience supplémentaire très solide devant le jury.

Liste du matériel

Câblage : Arduino Uno, ESP32 et Pico

Une patte de chaque LDR va à l'alimentation (5V sur l'Uno, 3V3 sur l'ESP32 et la Pico) et l'autre à une broche analogique ; une résistance fixe relie cette même broche à GND. Ainsi, la valeur lue augmente avec la lumière. Côté panneaux, une résistance de charge (33 Ω) est branchée entre les deux bornes de chaque panneau. La tension du panneau est divisée par 3,2 grâce à un pont de 22 kΩ et 10 kΩ avant d'arriver à la broche analogique : 22 kΩ de la borne positive du panneau à la broche analogique, 10 kΩ de la broche analogique à GND. La borne négative du panneau doit aussi être reliée au GND de la carte ; sans masse commune, la mesure n'a aucun sens.

Mécanique : support pan-tilt et équilibre du panneau

La solution mécanique la plus simple est un support pan-tilt tout prêt qui superpose deux servos SG90 : le servo du bas fait tourner le panneau à l'horizontale (est–ouest), celui du haut l'incline à la verticale. Fixe le bloc capteur sur le bord du panneau de façon que sa surface soit parfaitement parallèle à celle du panneau. Si le capteur regarde dans une autre direction que le panneau, le système suit parfaitement le soleil mais le panneau vise toujours quelques degrés à côté. Un mini panneau 6 V 1 W de 110×60 mm pèse environ 22 g ; à 3 cm de l'axe, cela représente environ 0,07 kg·cm de couple, bien en dessous des 1,8 kg·cm du SG90. La vraie charge, c'est le vent : si tu fais tes essais dehors, centre le panneau sur l'axe du servo, prends le MG90S à pignons métalliques et, pour des panneaux plus grands, passe à un servo puissant comme le MG996R. Laisse une boucle de câble lâche pour la rotation ; un câble tendu force le servo et arrache les connexions. Pour les bases sur les servos, lis qu'est-ce qu'un servomoteur.

Montage étape par étape

1. Soude les quatre LDR sur un morceau de plaque à trous en carré de 2×2 et colle entre elles une cloison en croix de 2–3 cm de haut en carton ou imprimée en 3D ; peins-la en noir mat ou recouvre-la de ruban adhésif noir.
2. Monte le pont diviseur de chaque LDR : la LDR de l'alimentation vers la broche analogique, la résistance fixe de la broche analogique vers GND.
3. Installe les servos dans le support pan-tilt, mets-les tous les deux à 90° et visse les palonniers en position centrale.
4. Fixe le panneau et le bloc capteur sur le support du haut, avec leurs surfaces parallèles.
5. Monte le circuit de mesure du panneau : résistance de charge entre les bornes du panneau, pont diviseur entre la borne positive et GND, point milieu sur A4.
6. Alimente les servos avec la source externe de 5 V, relie tous les GND et branche le condensateur de 470 µF en parallèle sur l'alimentation des servos.
7. Téléverse d'abord le code de calibrage, puis le code de suivi, et teste le système avec une lampe torche.

Étape 1 : tester et calibrer les LDR

Même des LDR du même sachet donnent des valeurs nettement différentes sous la même lumière ; la fiche technique de la GL5528 indique une plage aussi large que 10–20 kΩ à 10 lux. Un capteur non calibré croit qu'un côté est plus éclairé alors qu'il est pile face au soleil, et tourne le panneau de quelques degrés dans la mauvaise direction. Téléverse le code ci-dessous, ouvre le Traceur série depuis le menu Outils et éclaire le bloc capteur de façon homogène ; une feuille de papier blanc tendue devant une lampe diffuse et égalise bien la lumière.

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}

Sous la même lumière, les quatre courbes doivent être au même niveau. Imaginons que les valeurs soient 612, 640, 598 et 625 ; la moyenne vaut 619. La correction de chaque LDR est la moyenne moins sa propre valeur : +7, −21, +21 et −6. Tu inscris ces nombres dans le tableau OFFSET du code de l'étape 3. Comme la résistance d'une LDR ne varie pas linéairement avec la lumière, calibrer sous une luminosité proche de celle de l'utilisation réelle donne le résultat le plus juste. Le Traceur série te montre aussi le bruit : note de combien d'unités les valeurs bougent sans que tu touches à rien, car tu auras besoin de ce chiffre pour choisir la zone morte.

Étape 2 : code du suiveur solaire à un axe

Regardons d'abord la logique sur un seul axe. Deux LDR, séparées par un mur d'ombre vertical, regardent vers l'est et vers l'ouest : A0 est la LDR est, A1 la LDR ouest. Le code soustrait une valeur de l'autre ; si l'écart dépasse la zone morte, le servo tourne de 1° vers le côté le plus éclairé, sinon il reste immobile. Ce court programme est déjà un suiveur à un axe complet. Si le panneau fuit la lumière, inverse angle++ et angle-- dans les deux conditions.

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}

Avec delay(30), le servo tourne au maximum de 1° toutes les 30 ms, soit environ 33° par seconde : pendant une démonstration, le panneau suit sans peine une lampe torche. Le soleil se déplace beaucoup plus lentement, donc en usage réel une correction toutes les quelques secondes suffit.

Étape 3 : code à deux axes, zone morte et enregistrement des données

La version complète calcule deux écarts à partir des quatre LDR, corrige chaque axe séparément, gare le panneau en position du matin à la tombée de la nuit et, une fois par minute, écrit dans le Moniteur série la tension, la puissance et l'énergie accumulée des deux panneaux au format CSV. Le code utilise millis() au lieu de delay(), pour que le suivi et l'enregistrement tournent sans s'attendre. Les détails sont dans millis au lieu de 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}

Éviter les tremblements avec une zone morte (tolérance)

Sans zone morte, le système ne s'arrête jamais. Même pile face au soleil, les valeurs des LDR bougent de quelques unités à cause du bruit, l'écart passe du positif au négatif et le servo fait sans arrêt 1° à droite, 1° à gauche. Ces tremblements usent les pignons du servo et gaspillent de l'énergie. La solution consiste à ignorer les petits écarts : si l'écart est sous une certaine limite, on ne fait rien. Sers-toi du bruit observé pendant le calibrage pour choisir la limite et prends une zone morte au moins 3 à 4 fois plus grande que le bruit. Sur l'Uno, si le bruit tourne autour de ±5 unités, 20–40 est un bon point de départ.

La méthode du code va un cran plus loin : l'hystérésis. Le servo démarre quand l'écart dépasse 40, mais ne s'arrête que lorsqu'il repasse sous 15. Avec une zone morte à une seule limite, le panneau s'arrête pile au bord de la limite, et un petit nuage ou une rafale le remet en mouvement ; le système à deux limites amène à chaque fois le panneau bien face au soleil, puis se calme. L'effet de la zone morte sur l'énergie est négligeable : comme le montre le tableau du cosinus, quelques degrés d'écart représentent moins de 1 % de perte. Pour d'autres méthodes de filtrage, vois filtrer les données d'un capteur.

Expérience de rendement : panneau suiveur contre panneau fixe

La seule façon de prouver que le suiveur sert à quelque chose, c'est de mesurer. L'erreur fréquente consiste à ne mesurer que la tension à vide (circuit ouvert) du panneau. Cette tension varie très peu avec la lumière : quand la lumière diminue de moitié, le courant baisse aussi à peu près de moitié, mais la tension à vide ne perd que 3 à 5 %. Les deux panneaux affichent alors environ 7 V et l'écart disparaît. La bonne méthode consiste à brancher la même résistance de charge sur chaque panneau et à mesurer la tension à ses bornes. La puissance s'obtient avec P = V² / R, et l'énergie en additionnant la puissance au fil du temps. Choisis la résistance de charge selon le point de puissance maximale du panneau : un panneau 6 V 1 W fournit environ 1 / 6 = 0,17 A, la résistance adaptée vaut donc 6 / 0,17 ≈ 36 Ω ; une valeur normalisée de 33 Ω est un bon choix. Comme la résistance dissipe près de 1 W en chaleur, prends-en une d'au moins 2 W, idéalement une résistance céramique de 5 W. Tu peux vérifier les calculs avec le calculateur de loi d'Ohm.

1. Utilise deux panneaux identiques : même modèle, si possible du même lot. Branche sur chacun une résistance de charge de 33 Ω et un pont diviseur 22 kΩ / 10 kΩ ; le panneau suiveur va sur A4, le fixe sur A5.
2. Fais un essai préalable : fixe les deux panneaux côte à côte avec la même orientation et la même inclinaison, et mesure pendant 30 à 60 minutes. Note l'écart (par exemple 2 %) et corrige tes résultats avec. Mieux encore, échange les panneaux le deuxième jour.
3. Oriente le panneau fixe plein sud et règle son inclinaison sur le soleil de midi du jour (vois l'avertissement plus bas).
4. Écarte suffisamment les panneaux pour qu'aucun ne fasse d'ombre à l'autre ni au capteur, dans un endroit sans ombre d'arbre ou de mur.
5. Mesure une fois la tension du panneau au multimètre et compare-la à la valeur lue par l'Arduino ; en cas d'écart, corrige DIVIDER (comment utiliser un multimètre).
6. Enregistre une fois par minute du lever au coucher du soleil et note la météo (dégagé, partiellement nuageux, couvert).
7. Répète l'expérience sur au moins trois jours dégagés, enregistre à part un jour couvert et compare l'énergie quotidienne moyenne.

Tu peux copier les données du Moniteur série et les enregistrer dans un fichier CSV ou les envoyer directement dans Excel (envoyer des données Arduino vers Excel) ; si tu ne veux pas rester à côté de l'ordinateur, ajoute un module carte SD. Sur le graphique d'une journée dégagée, la courbe du panneau suiveur reste nettement au-dessus le matin et le soir, tandis que vers midi les deux courbes se superposent presque. Pour les grandes installations, on cite des gains d'énergie d'environ 15–35 % pour un axe et 30–45 % pour deux axes ; avec un petit montage, le résultat dépend beaucoup de la météo, de la saison et de la qualité d'orientation du panneau fixe. Écris clairement dans ton rapport que tu n'as pas mesuré le rendement du panneau lui-même, mais l'augmentation de l'énergie captée par un même panneau. Ajoute aussi une limite : sur une résistance de charge fixe, la puissance varie comme le carré du courant, donc quand la lumière faiblit, la puissance du panneau baisse plus vite que la lumière ; le gain en pourcentage que tu mesures peut ainsi être plus élevé que dans une vraie installation avec régulateur de charge. Si tu additionnes et compares aussi les courants des deux panneaux (V / R), tu verras aussi l'écart réel de lumière qu'ils reçoivent.

Bilan énergétique : le système peut-il s'alimenter lui-même ?

C'est la question préférée des jurys. Un suiveur fait gagner de l'énergie, mais il en consomme aussi. Pour une petite maquette, le calcul approximatif donne ceci :

Le tableau est sans appel : une petite maquette ne produit pas assez d'énergie pour faire tourner sa propre électronique. Les quelque 1 à 1,5 Wh gagnés grâce au suivi pèsent peu face aux 6 Wh environ que l'Uno consomme par jour. Ce n'est pas un échec, c'est un résultat honnête et précieux. Quand l'échelle augmente, la situation s'inverse : la consommation du moteur et du contrôleur qui orientent des panneaux de plusieurs kilowatts devient une petite fraction de la production. Pour réduire la consommation d'un petit système, corrige une fois par minute, libère les servos avec detach() quand ils ne bougent pas, et préfère à l'Uno un Pro Mini qui se met en veille ou un ESP32 en deep sleep. Pour estimer l'autonomie sur batterie, utilise le calculateur d'autonomie de batterie et le guide mAh et Wh.

Suiveur solaire avec ESP32 et suivi depuis le téléphone

L'ESP32 exécute la même logique avec un ADC plus fin et le Wi-Fi. Quelques différences sont à surveiller. Les valeurs analogiques vont de 0 à 4095 : la zone morte est donc environ 4 fois plus grande que sur l'Uno. Quand le Wi-Fi est actif, seules les broches ADC1 (GPIO 32–39) fonctionnent de façon fiable, car les broches ADC2 sont utilisées par le Wi-Fi. Pour les servos, installe la bibliothèque ESP32Servo depuis le Gestionnaire de bibliothèques. La fonction analogReadMilliVolts(), utilisée pour mesurer la tension du panneau, corrige le comportement non linéaire de l'ADC de l'ESP32 grâce au calibrage d'usine. Alimente toujours les ponts des LDR en 3V3. Après le téléversement, ouvre sur un téléphone connecté au même réseau l'adresse IP affichée dans le Moniteur série : tu verras la tension en direct des deux panneaux, l'énergie accumulée et le gain. Si tu débutes avec l'ESP32, commence par qu'est-ce que 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}

Si tu veux conserver les mesures pendant plusieurs jours, tu peux envoyer les mêmes valeurs vers un tableur en ligne ; vois enregistrer les données de l'ESP32 dans Google Sheets. Tu trouveras plus d'informations sur la résolution de l'ADC et la tension de référence dans ADC et conversion analogique-numérique.

Suivi à un axe avec Raspberry Pi Pico et MicroPython

La Pico ne dispose que de trois entrées analogiques accessibles (GP26, GP27, GP28), ce qui ne suffit pas pour quatre LDR et deux panneaux. La solution la plus propre avec la Pico est donc un suiveur à un axe : deux LDR trouvent la direction et la troisième entrée analogique mesure la tension du panneau. Pour deux axes, tu peux ajouter un ADC externe I2C comme l'ADS1115 à 4 canaux. Le servo est piloté directement en PWM à 50 Hz : une impulsion de 500 µs correspond à 0°, une de 2400 µs à 180°. Comme read_u16() renvoie des valeurs sur une échelle de 0 à 65535, la zone morte est un grand nombre comme 2000. Pour installer MicroPython sur la Pico, vois qu'est-ce que la 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)

Le code ajoute les mesures au fichier log.csv dans la mémoire flash de la Pico. Une ligne par minute représente 30 à 40 Ko par jour : le système de fichiers d'environ 1,4 Mo de la Pico tient donc des semaines. Si tu enregistres le fichier sous le nom main.py, la Pico lance le programme toute seule dès qu'elle est alimentée par une batterie ou un chargeur USB, sans ordinateur. En fin de journée, tu peux récupérer log.csv sur ton ordinateur avec Thonny et l'ouvrir dans Excel.

Conseils pour un concours scientifique

Le suiveur solaire est un projet fréquent dans les concours scientifiques et les fêtes de la science ; ce qui fera sortir le tien du lot, ce n'est pas la maquette, mais tes données mesurées et la façon dont tu les interprètes. Pour des idées et la structure du rapport, consulte aussi projets Arduino pour l'école.

• Pose une question mesurable : De combien de pour cent un suivi à deux axes capte-t-il plus d'énergie, lors d'une journée dégagée d'automne, qu'un panneau identique fixé plein sud avec le meilleur angle ?
• Écris ton hypothèse à l'avance : Prédis par exemple que le gain se concentrera le matin et le soir ; même si le résultat ne la confirme pas, la discuter rapporte des points.
• Sépare les variables : La variable indépendante est la méthode de suivi (aucune, un axe, deux axes), la variable dépendante l'énergie quotidienne (Wh), les variables contrôlées le modèle de panneau, la résistance de charge, le lieu et la date.
• Raconte avec des graphiques : Une courbe heure–puissance montre les deux panneaux superposés ; compare l'énergie quotidienne avec un histogramme et indique l'écart entre les jours comme marge d'erreur.
• Parle de l'énergie nette : Mesure la consommation propre du système et mets le tableau du bilan énergétique sur ton poster ; cela montre que le projet est honnête et scientifique.
• Il n'y a pas de soleil dans la salle d'exposition : Fais la démonstration en direct avec une lampe torche ou un spot, et apporte une vidéo en accéléré de l'expérience en extérieur ainsi que le fichier CSV brut.
• Organise le poster : Problème, méthode, schéma du circuit, organigramme du code, résultats, limites et pistes d'amélioration ; des phrases courtes et de grands graphiques dans chaque partie.
• Annonce toi-même les limites : Citer le petit panneau, le faible nombre de jours de mesure, le vent et les différences entre LDR avant que le jury pose la question inspire confiance.

Erreurs fréquentes et solutions

Idées pour aller plus loin

• Station de recharge solaire : Branche le panneau suiveur sur un module de charge TP4056 et un accu 18650, puis compare le temps de charge avec celui du panneau fixe.
• Suivi hybride : Calcule la position du soleil avec un module horloge RTC et n'utilise les LDR que pour affiner ; le panneau vise juste même par temps nuageux.
• Enregistrement par Wi-Fi : Envoie les mesures de l'ESP32 vers Google Sheets et suis le graphique en direct sur ton téléphone.
• Serre solaire : Utilise le panneau suiveur pour alimenter le ventilateur et l'arrosage d'une maquette de serre connectée.
• Scanner de lumière : Réalise une version qui balaie une seule LDR de 0 à 180° avec un servo et cherche la direction la plus lumineuse ; la logique ressemble beaucoup au projet de radar Arduino.
• Mesure de puissance plus précise : En plus de la résistance de charge, utilise un capteur de puissance I2C comme l'INA219, qui mesure courant et tension en même temps, et trace la courbe de puissance du panneau.

Un suiveur solaire réunit dans un seul projet la lecture de capteurs, la prise de décision, la commande de moteurs et la mesure scientifique : c'est un excellent choix pour apprendre comme pour présenter à un concours. Commence avec un axe, règle la zone morte, puis ajoute le deuxième axe et l'expérience avec le panneau fixe. Dans l'application BlueGrays, tu trouveras des projets pour essayer séparément chaque partie de ce système, comme mesurer la lumière avec une LDR, une veilleuse, le contrôle de l'angle d'un servo et un voltmètre numérique, avec schémas et code.