Suiveur Solaire IoT : Gestion Intelligente de l'Énergie avec Arduino

Composants et fournitures

Composant	Quantité	Notes
Arduino Mega 2560	1	Contrôleur principal
Shield Ethernet (Wiznet W5100) pour Arduino	1	Connexion Internet via RJ45
Servomoteur SG90 (micro-servo)	2	Axe horizontal (SG90) et vertical (MG996R)
LDR (photorésistance) 5 MΩ	4	Capteurs de position solaire (coins du panneau)
Capteur température/humidité DHT22	1	Plage : -40 à 80°C, 0-100% HR
Mini panneau solaire	1	115×85 mm, 1,6 W, jusqu'à 6 V
Résistance 330 Ω	4	Pour diviseurs de tension LDR
Résistance 10 Ω (traversante)	2	Diviseur tension/courant PV
Résistance 220 Ω	1	Pour LED indicatrice
LED 5 mm rouge	1	Indique mode auto/manuel

Applications et services en ligne

• myDevices Cayenne : Plateforme IoT pour tableau de bord, alertes SMS/Email, contrôle manuel
• Arduino IDE : Développement et téléversement du code

À propos de ce projet

Ce projet présente une solution IoT simple et peu coûteuse pour surveiller et contrôler un système de suivi solaire biaxial intelligent afin d'évaluer ses performances.

Architecture du système

Le suiveur solaire biaxial (Fig. 1) peut pivoter automatiquement pour suivre la position du soleil via 4 capteurs LDR, ou manuellement par l'utilisateur via le tableau de bord d'une application IoT. Le système fonctionne comme suit :

1. Détection : Les 4 LDR (coin du panneau) mesurent l'intensité lumineuse et envoient les données à l'Arduino Mega.
2. Traitement : L'Arduino compare les valeurs moyennes (gauche/droite, haut/bas) et commande les deux servomoteurs (SM1 axe vertical Est/Ouest, SM2 axe horizontal Sud/Nord) pour orienter le panneau photovoltaïque (PV) vers le soleil.
3. Mesures complémentaires : Tension/courant PV (via diviseur de tension), température/humidité (DHT22) sont également acquis.
4. Communication IoT : Le shield Ethernet (Wiznet W5100) connecte l'Arduino à Internet et envoie les données vers le cloud (serveur Cayenne).
5. Visualisation et contrôle : L'application Cayenne affiche en temps réel : valeurs LDR, puissance PV, température, humidité. L'utilisateur peut basculer en mode manuel et contrôler les servos via des curseurs, et recevoir des alertes (SMS/Email) sur seuils configurables.

Conception matérielle

Le système (Fig. 2) comprend : panneau PV, deux servomoteurs 180°, quatre LDR (Cds GL5528) aux coins du panneau, circuit diviseur de tension pour LDR (résistance série 330 Ω), capteur DHT22 (broche numérique 2), diviseur de tension pour mesure PV (deux résistances 10 Ω en série, sortie sur A4), LED indicatrice de mode (broche 3), Arduino Mega 2560 + shield Ethernet W5100 connecté via RJ45 à un routeur Wi-Fi.

Détails techniques :

• Servomoteurs : L-R (MG996R) sur broche PWM 6 pour rotation verticale Est/Ouest ; U-D (SG90) sur broche PWM 5 pour rotation horizontale Sud/Nord.
• LDR : Connectés aux entrées analogiques A0-A3. La résistance de charge 330 Ω forme un diviseur de tension ; l'ADC 10 bits de l'Arduino convertit en valeur 0-1023.
• DHT22 : Thermistance + capteur capacitif ; précision ±0,5°C (température), ±2% HR (humidité) ; fil de signal sur broche digitale 2.
• Mesure PV : Diviseur de tension (2×10 Ω) agissant aussi comme charge ; sortie sur A4. Tension = Vout × 2, Courant = Vout / 10, Puissance = Tension × Courant.
• Ethernet Shield W5100 : Pile TCP/IP intégrée, protocoles TCP/UDP ; monté sur l'Arduino Mega.

Conception logicielle

a. Arduino IDE

Plateforme open-source avec support C/C++. L'IDE permet d'écrire, compiler et téléverser le code sur l'Arduino Mega via USB.

b. Plateforme myDevices Cayenne

Cayenne utilise le protocole MQTT (Message Queuing Telemetry Transport) basé sur TCP/IP pour connecter les appareils au cloud. Le modèle publish/subscribe utilise un broker (le cloud Cayenne) qui gère la distribution des messages entre clients (capteurs/actionneurs).

Pour Arduino + Ethernet : installer la bibliothèque CayenneMQTTEthernet via le gestionnaire de bibliothèques. Configuration :

• Identifiants MQTT (username, password, client ID) depuis le tableau de bord Cayenne
• Cayenne.begin(username, password, clientID) dans setup() pour établir la connexion
• Fonctions CAYENNE_IN(VIRTUAL_CHANNEL) pour actionneurs (servos, bouton mode)
• Fonctions CAYENNE_OUT(VIRTUAL_CHANNEL) pour capteurs (LDR, PV, DHT22)
• Cayenne.loop() dans loop() pour gérer la communication

Les canaux virtuels (0-31) lient les widgets du tableau de bord aux capteurs/actionneurs physiques.

c. Logiciel embarqué

Deux modes de fonctionnement gérés par un bouton virtuel sur Cayenne :

(i) Basculement de mode : Bouton inactif = mode manuel ; actif = mode automatique. Une LED sur broche 3 reflète l'état (éteinte = manuel, allumée = auto). Le code teste digitalRead(3) pour déterminer le mode.

(ii) Mode manuel : L'utilisateur contrôle directement les angles des servomoteurs via les widgets curseurs du tableau de bord. Cayenne.loop() appelle les fonctions CAYENNE_IN (servos) et CAYENNE_OUT (capteurs) pour mise à jour.

(iii) Mode automatique : Algorithme de suivi solaire (Fig. 4) :

1. Lecture des 4 valeurs analogiques LDR (A0-A3)
2. Calcul moyennes : haut (topL+topR)/2, bas (botL+botR)/2, gauche (topL+botL)/2, droite (topR+botR)/2
3. Axe horizontal (U-D servo) : Différence haut-bas. Si |diff| ≤ seuil (10) → arrêt. Si diff > seuil → rotation horaire (CW) ; sinon anti-horaire (CCW). Limites : 10° à 170°.
4. Axe vertical (L-R servo) : Différence gauche-droite. Même logique avec seuil 10. Limites : 10° à 170°.
5. En parallèle, Cayenne.loop() envoie les données télémétriques.

d. Développement de l'application de surveillance IoT

(i) Interfaçage matériel avec Cayenne :

1. Créer un compte sur Cayenne myDevices
2. Choisir "Bring Your Own Things" dans l'API Cayenne
3. Copier les identifiants MQTT (username, password, client ID) et les coller dans le code Arduino
4. Compiler et téléverser ; ouvrir le Moniteur Série pour voir les logs de connexion Cayenne
5. Une fois l'appareil en ligne, il apparaît dans le tableau de bord
6. Ajouter les widgets : "Value" pour tous les capteurs, "Button" pour commutation de mode, "Slider" pour servomoteurs (canal virtuel identique au code)

(ii) Création d'alertes : Cayenne permet de configurer des déclencheurs (Triggers) pour envoyer notifications SMS/Email ou actions quand un capteur atteint un seuil. Exemple : alerte température → email si dépassement. Configuration : "Add new..." → "Trigger" → définir événement/action → "Save".

Prototype

Le prototype (Fig. 12-13) montre le panneau PV monté sur le servomoteur U-D d'un côté et sur un roulement de l'autre pour flexibilité. L'ensemble est fixé au servomoteur L-R. Les LDR sont insérés dans des cylindres creux aux 4 coins du panneau : si le panuille n'est pas perpendiculaire au soleil, au moins un LDR est ombragé par son cylindre, créant une différence d'intensité. L'orientation optimale égalise la lumière sur les 4 LDR.

Pour plus de détails sur les résultats expérimentaux, consulter l'article : Springer Link

Code embarqué

/***************************************************************
 * PROJET : Système suiveur solaire IoT / logiciel embarqué
 * Auteur : Aboubakr El Hammoumi / aboubakr.elhammoumi@usmba.ac.ma
 ***************************************************************/
#define CAYENNE_PRINT Serial
#include <CayenneMQTTEthernet.h>
#include <Servo.h>
#include <DHT.h>

#define DHTTYPE DHT22
#define DHTPIN 2
DHT dht(DHTPIN, DHTTYPE);

// Identifiants MQTT Cayenne (à remplacer par les vôtres)
char username[] = "498d2d00-afe2-11ea-883c-638d8ce4c23d";
char password[] = "ab4a8f92d94033c01f6e18ce1d8a84d8c304c9c4";
char clientID[] = "17798a40-b968-11ea-93bf-d33a96695544";

Servo servo_x;  // Servo up-down (horizontal)
int servoh = 0;
int servohLimitHigh = 170;
int servohLimitLow = 10;

Servo servo_z;  // Servo left-right (vertical)
int servov = 0;
int servovLimitHigh = 170;
int servovLimitLow = 10;

int topl, topr, botl, botr;
int threshold_value = 10;
float Vout;

void setup() {
  Serial.begin(9600);
  Cayenne.begin(username, password, clientID);
  servo_x.attach(5);  // U-D servo
  servo_z.attach(6);  // L-R servo
  dht.begin();
  pinMode(3, OUTPUT);
  digitalWrite(3, LOW);  // Mode manuel par défaut (LED éteinte)
}

void loop() {
  // Lecture capteurs LDR
  topr = analogRead(A2);
  topl = analogRead(A3);
  botl = analogRead(A4);
  botr = analogRead(A5);
  
  // Lecture tension PV (diviseur sur A1)
  Vout = (analogRead(A1) * 5.0) / 1023;
  
  Serial.println("Manual-mode");
  Cayenne.loop();  // Gère communication Cayenne (mode manuel)
  
  // Test mode automatique (LED broche 3 allumée)
  if (digitalRead(3) == HIGH) {
    Serial.println("Automatic-mode");
    servoh = servo_x.read();
    servov = servo_z.read();
    
    // Calcul moyennes LDR
    int avgtop = (topr + topl) / 2;
    int avgbot = (botr + botl) / 2;
    int avgright = (topr + botr) / 2;
    int avgleft = (topl + botl) / 2;
    
    int diffhori = avgtop - avgbot;      // Différence axe horizontal
    int diffverti = avgleft - avgright;  // Différence axe vertical
    
    /* Suivi axe horizontal (servo U-D) */
    if (abs(diffhori) <= threshold_value) {
      servo_x.write(servoh);  // Arrêt
    } else {
      if (diffhori > threshold_value) {
        Serial.println("x - 2");
        servo_x.write(servoh - 2);  // Rotation horaire (CW)
        if (servoh > servohLimitHigh) servoh = servohLimitHigh;
        delay(10);
      } else {
        servo_x.write(servoh + 2);  // Rotation anti-horaire (CCW)
        if (servoh < servohLimitLow) servoh = servohLimitLow;
        delay(10);
      }
    }
    
    /* Suivi axe vertical (servo L-R) */
    if (abs(diffverti) <= threshold_value) {
      servo_z.write(servov);  // Arrêt
    } else {
      if (diffverti > threshold_value) {
        servo_z.write(servov - 2);  // CW
        if (servov > servovLimitHigh) servov = servovLimitHigh;
        delay(10);
      } else {
        servo_z.write(servov + 2);  // CCW
        if (servov < servovLimitLow) servov = servovLimitLow;
        delay(10);
      }
    }
  }
}

// Fonctions Cayenne pour actionneurs (CAYENNE_IN)
CAYENNE_IN(8) {  // Bouton commutation mode (canal virtuel 8)
  int value = getValue.asInt();
  CAYENNE_LOG("Channel %d, pin %d, value %d", 8, 3, value);
  digitalWrite(3, value);  // Met à jour LED indicatrice
}

CAYENNE_IN(7) {  // Servo U-D manuel (canal 7)
  if (digitalRead(3) == HIGH) {
    // Mode auto : ignorer commande manuelle
  } else {
    servo_x.write(getValue.asDouble() * 180);  // Slider 0-1 → angle 0-180°
  }
}

CAYENNE_IN(6) {  // Servo L-R manuel (canal 6)
  if (digitalRead(3) == HIGH) {
    // Mode auto : ignorer
  } else {
    servo_z.write(getValue.asDouble() * 180);
  }
}

// Fonctions Cayenne pour capteurs (CAYENNE_OUT)
CAYENNE_OUT(0) {  // Courant PV (canal 0)
  float current = Vout / 10;
  Cayenne.virtualWrite(0, current);
  Serial.print("Current: "); Serial.println(current);
}

CAYENNE_OUT(1) {  // Tension PV (canal 1)
  float voltage = Vout * 2;
  Cayenne.virtualWrite(1, voltage);
  Serial.print("Voltage: "); Serial.println(voltage);
}

CAYENNE_OUT(2) { Cayenne.virtualWrite(2, topr); }   // LDR Top-Right
CAYENNE_OUT(3) { Cayenne.virtualWrite(3, topl); }   // LDR Top-Left
CAYENNE_OUT(4) { Cayenne.virtualWrite(4, botl); }   // LDR Bot-Left
CAYENNE_OUT(5) { Cayenne.virtualWrite(5, botr); }   // LDR Bot-Right

CAYENNE_OUT(10) {  // Puissance PV (canal 10)
  float power = (Vout * 2 * Vout) / 10;
  Cayenne.virtualWrite(10, power);
  Serial.print("Power: "); Serial.println(power);
}

CAYENNE_OUT(11) {  // Température DHT22 (canal 11)
  float t = dht.readTemperature();
  Cayenne.virtualWrite(11, t, TYPE_TEMPERATURE, UNIT_CELSIUS);
  Serial.print("temperature: "); Serial.println(t);
}

CAYENNE_OUT(12) {  // Humidité DHT22 (canal 12)
  float h = dht.readHumidity();
  Cayenne.virtualWrite(12, h);
  Serial.print("humidity: "); Serial.println(h);
}

Schéma électrique

Points clés et améliorations

• Seuil de stabilité (10) : Évite les micro-mouvements constants des servos, réduisant l'usure et la consommation.
• Limites mécaniques (10°-170°) : Protègent les servomoteurs contre les butsées.
• Mode manuel prioritaire : L'utilisateur reprend le contrôle instantanément via le tableau de bord.
• Alertes configurables : Surveillance proactive (surchauffe, faible luminosité, etc.).
• Évolutivité : Ajout possible de capteurs (irradiance, vent), stockage de données historiques, algorithmes MPPT.