Suiveur solaire bi-axe avec Arduino UNO – Alignement panneau photovoltaïque DIY

Composants et fournitures

Arduino UNO	×	1
Micro-servomoteur SG90	×	2
LDR (photorésistance) 5 MΩ	×	4
Résistance 330 Ω	×	4
Potentiomètre rotatif (générique)	×	1
Bouton poussoir	×	2
Mini panneau solaire	×	1

Outils et machines nécessaires

• Arduino IDE
• Parallax PLX-DAQ (macro Excel pour acquisition de données)

À propos du projet

Ce projet présente un banc de test open-source hardware/logiciel pour suiveur solaire. Le prototype est basé sur un suiveur solaire bi-axe contrôlé par un Arduino Uno, plateforme de prototypage open-source à matériel et logiciel faciles d'utilisation. Le suiveur peut être contrôlé automatiquement grâce à quatre capteurs LDR (photorésistances) ou manuellement via un potentiomètre. De plus, ce banc fournit une instrumentation virtuelle basée sur Excel pour enregistrer et présenter les données du suiveur. Le matériel a été choisi pour être peu coûteux, compact et polyvalent. Ce banc est conçu pour aider les étudiants à développer leur compréhension de la théorie du contrôle et de ses applications.

Conception mécanique

Le modèle CAO 3D du suiveur a été conçu dans CATIA. Il est composé du panneau PV, des servomoteurs gauche-droite et haut-bas, et de quatre capteurs LDR. Pour l'axe horizontal, un roulement est fixé en parallèle avec le servomoteur haut-bas pour une meilleure flexibilité. Le suiveur a deux degrés de liberté : est-ouest (servo gauche-droite) et sud-nord (servo haut-bas). Les LDR sont placés aux quatre coins du panneau PV, insérés dans des tubes sombres avec un petit orifice sur le dessus pour détecter l'ensoleillement. Ces tubes agissent comme concentrateurs de rayonnement et augmentent la robustesse du suiveur.

Système matériel

Le circuit électronique : en mode automatique, le microcontrôleur convertit les valeurs analogiques des LDR (broches A0-A3) en numériques, puis contrôle deux servomoteurs via deux signaux PWM (broches 5 et 6) pour suivre le soleil. Les mouvements de rotation se font sur deux axes : azimut (est-ouest) selon la course quotidienne du soleil, et élévation (sud-nord) selon la course saisonnière. En mode manuel, un potentiomètre (broche A4) contrôle les deux servos, un bouton (broche 11) bascule le potentiomètre entre les deux moteurs, et un autre bouton (broche 12) commute entre modes automatique et manuel. La tension PV est mesurée sur la broche analogique A5, le courant est calculé (résistance de charge connue), puis tension, courant, puissance et mode sont envoyés à l'ordinateur pour affichage temps réel dans MS Excel.

Le circuit LDR est un diviseur de tension : la variation d'intensité lumineuse est proportionnelle à la variation de la tension de sortie. Le haut du diviseur est à 5V, la masse à 0V, la sortie connectée à une entrée analogique. L'ADC 10 bits convertit en valeur 0-1023. Les résistances du diviseur valent 330 Ω.

Deux servomoteurs 180° sont utilisés : un MG996R pour l'axe vertical (gauche-droite) et un micro-servo SG90 pour l'axe horizontal (haut-bas). L'avantage du servomoteur est qu'on contrôle son arrêt, marche, sens et vitesse via un seul fil de commande PWM à faible courant, directement sur une sortie du microcontrôleur, sans driver.

Conception logicielle embarquée

Le logiciel embarqué dans l'Arduino Uno contrôle et surveille le banc de test. Il couvre les exigences suivantes :

1. Deux modes : manuel et automatique. Un bouton sur la broche 12 permet de basculer.
2. En mode manuel, le potentiomètre contrôle soit le moteur gauche-droite (est-ouest), soit le moteur haut-bas (sud-nord). Un bouton sur la broche 11 bascule entre les deux moteurs.
3. En mode automatique, l'algorithme compare les valeurs moyennes des LDR gauche/droite et haut/bas. Si la différence dépasse un seuil (±10), le servo correspondant tourne jusqu'à ce que la différence revienne dans la plage. La moyenne des quatre LDR détermine la nuit (valeur < 8) : le suiveur revient alors en position lever du soleil (ex: 0° gauche-droite, 30° haut-bas).
4. La tension PV (broche A5) est traitée pour calculer courant et puissance. Toutes ces données et le mode sont envoyées via USB à l'ordinateur pour affichage dans MS Excel via la macro PLX-DAQ.

PLX-DAQ : macro Excel pour acquisition de données depuis l'Arduino. Après installation, un dossier "PLX-DAQ" est créé avec un raccourci "PLX-DAQ Spreadsheet". Ouvrir le classeur, régler le débit (baud rate) et le port COM dans la fenêtre PLX-DAQ, cliquer "Connect" pour collecter et afficher les données en temps réel.

Le prototype

La structure entière a été fabriquée en plaques de bois. La figure montre le suiveur en état démonté et assemblé, avec tous les composants (LDR, Arduino Uno, servos, potentiomètre, boutons, petit panneau PV). Le banc complet comprend le suiveur, l'instrumentation virtuelle, et une lampe artificielle pour tester. Le suiveur et l'ordinateur sont reliés par USB. Une fois la tension PV acquise, le contrôleur calcule courant et puissance, et envoie tout à Excel. Ce banc est petit, flexible et facile à utiliser, permettant aux étudiants, chercheurs et ingénieurs de tester leurs algorithmes avant d'implémenter un grand suiveur solaire.

Code

Logiciel embarqué du banc de test suiveur solaire

#include 

int mode = 0;
int axe = 0;
int buttonState1 = 0, buttonState2 = 0;
int prevButtonState1 = 0, prevButtonState2 = 0;
int ldrtopr = 0, ldrtopl = 1, ldrbotr = 2, ldrbotl = 3;
int topl = 0, topr = 0, botl = 0, botr = 0;

Servo servo_updown;
Servo servo_rightleft;
int threshold_value = 10;

void setup() {
  Serial.begin(9600);
  Serial.println("CLEARDATA");
  Serial.println("LABEL,t,voltage,current,power,Mode");
  
  pinMode(12, INPUT);
  pinMode(11, INPUT);
  pinMode(A4, INPUT);
  
  servo_updown.attach(5);
  servo_rightleft.attach(6);
}

void loop() {
  char Mode;
  float volt = analogRead(A5) * 5.0 / 1023;
  float voltage = 2 * volt;
  float current = voltage / 20;
  float power = voltage * current;
  
  Serial.print("DATA,TIME,");
  Serial.print(voltage); Serial.print(",");
  Serial.print(current); Serial.print(",");
  Serial.print(power); Serial.print(",");
  
  buttonState1 = digitalRead(12);
  if (buttonState1 != prevButtonState1) {
    if (buttonState1 == HIGH) {
      mode = (mode == 1) ? 0 : 1;
    }
  }
  prevButtonState1 = buttonState1;
  delay(50);
  
  if (mode == 0) {
    Mode = 'M';
    Serial.println(Mode);
    manualsolartracker();
  } else {
    Mode = 'A';
    Serial.println(Mode);
    automaticsolartracker();
  }
}

void automaticsolartracker() {
  topr = analogRead(ldrtopr);
  topl = analogRead(ldrtopl);
  botr = analogRead(ldrbotr);
  botl = analogRead(ldrbotl);
  
  int avgtop = (topr + topl) / 2;
  int avgbot = (botr + botl) / 2;
  int avgleft = (topl + botl) / 2;
  int avgright = (topr + botr) / 2;
  
  int diffelev = avgtop - avgbot;
  int diffazi = avgright - avgleft;
  
  // Mouvement gauche-droite (azimut)
  if (abs(diffazi) >= threshold_value) {
    if (diffazi > 0) {
      if (servo_rightleft.read() < 180) 
        servo_rightleft.write(servo_updown.read() + 2);
    }
    if (diffazi < 0) {
      if (servo_rightleft.read() > 0) 
        servo_rightleft.write(servo_updown.read() - 2);
    }
  }
  
  // Mouvement haut-bas (élévation)
  if (abs(diffelev) >= threshold_value) {
    if (diffelev > 0) {
      if (servo_updown.read() < 180) 
        servo_updown.write(servo_rightleft.read() - 2);
    }
    if (diffelev < 0) {
      if (servo_updown.read() > 0) 
        servo_updown.write(servo_rightleft.read() + 2);
    }
  }
}

void manualsolartracker() {
  buttonState2 = digitalRead(13);
  if (buttonState2 != prevButtonState2) {
    if (buttonState2 == HIGH) {
      axe = (axe == 1) ? 0 : 1;
    }
  }
  prevButtonState2 = buttonState2;
  delay(50);
  
  if (axe == 0) {
    servo_rightleft.write(map(analogRead(A4), 0, 1023, 0, 180));
  } else {
    servo_updown.write(map(analogRead(A4), 0, 1023, 0, 180));
  }
}

Schémas

Schéma de câblage complet disponible (voir fichier joint).