IoT-Solartracker: Intelligentes Energiemanagement mit Arduino Mega

Benötigte Bauteile

• 1× Arduino Mega 2560
• 1× Ethernet Shield (Wiznet W5100)
• 2× SG90 Micro-Servomotor (einer für horizontale, einer für vertikale Achse)
• 4× LDR (GL5528, 5 MΩ) – Lichtsensoren
• 1× DHT22 Temperatur- & Feuchtigkeitssensor
• 1× Mini-Solarpanel (ca. 115 × 85 mm, 1,6 W, bis 6 V)
• 4× 330 Ω Widerstand (für LDR-Spannungsteiler)
• 2× 10 Ω Widerstand (für PV-Spannungsteiler/Last)
• 1× 220 Ω Widerstand (für Status-LED)
• 1× rote 5 mm LED (Betriebsanzeige Auto/Manuell)
• Jumper-Kabel, Breadboard/Platine, Netzteil

Software & Plattformen

• Arduino IDE
• myDevices Cayenne (MQTT-basierte IoT-Plattform)
• Bibliotheken: CayenneMQTTEthernet, Servo, DHT

Projektübersicht

Dieses Projekt realisiert einen dual-achsigen Solartracker, der die Sonne automatisch über vier LDR-Sensoren nachführt oder manuell per Web-Dashboard gesteuert werden kann. Alle Sensordaten (LDR-Werte, PV-Spannung/-Strom/-Leistung, Temperatur, Luftfeuchte) werden in Echtzeit an die Cayenne-Cloud gesendet und dort visualisiert. Zudem lassen sich Schwellwert-Alarme (E-Mail/SMS) konfigurieren.

Hardware-Architektur

Servomotoren & Mechanik

• Horizontal (Ost/West): MG996R Servo an PWM-Pin 5
• Vertikal (Süd/Nord): SG90 Servo an PWM-Pin 6
• Das Panel ist auf der einen Seite am Vertikal-Servo, auf der anderen an einem Lager befestigt – für spielfreie Drehung.

LDR-Sensorik (Sonnenstandserkennung)

Vier LDRs sitzen in den Ecken des Panels, jeweils in einem Hülsenrohr. Fällt das Licht nicht senkrecht ein, wirft die Hülse Schatten auf mindestens einen LDR → Helligkeitsdifferenz → Nachführung.

• Anschluss: A0–A3 (analog)
• Schaltung: Spannungsteiler mit 330 Ω Festwiderstand
• ADC-Auflösung: 10 Bit (0–1023)

Umgebungssensorik

• DHT22 an Digitalpin 2 (Temperatur: –40…80 °C, ±0,5 °C; Feuchte: 0–100 %, ±2 %)
• PV-Messung: Spannungsteiler aus 2× 10 Ω an Analogpin A4 → ermöglicht Berechnung von Spannung, Strom (über Shunt) und Leistung

Kommunikation & Status

• Ethernet Shield (W5100) per RJ45 an Router → TCP/IP-Stack für MQTT
• Rote LED an Pin 3: AUS = Manuell, AN = Automatisch

Software-Design

Betriebsmodi

Ein Button im Cayenne-Dashboard (virtueller Kanal 8) schaltet zwischen:

• Manuell: User steuert beide Servos per Slider-Widgets (Kanäle 6 & 7) direkt an.
• Automatisch: Algorithmus vergleicht LDR-Mittelwerte (links/rechts, oben/unten) und bewegt Servos schrittweise (±2°), bis Differenz ≤ 10 (Hysterese gegen Flattern).

Datenfluss

Im loop() wird stets Cayenne.loop() aufgerufen, das alle CAYENNE_OUT-Funktionen (Sensoren → Cloud) und CAYENNE_IN-Funktionen (Aktoren ← Cloud) abarbeitet. Im Automatikmodus läuft zusätzlich der Tracking-Algorithmus.

Wichtige virtuelle Kanäle (Cayenne)

Kanal	Typ	Funktion
0	Sensor	PV-Strom (A)
1	Sensor	PV-Spannung (V)
2–5	Sensor	LDR: Top-R, Top-L, Bot-L, Bot-R
6	Aktor	Slider: Vertikal-Servo (U-D)
7	Aktor	Slider: Horizontal-Servo (L-R)
8	Aktor	Button: Moduswahl (Auto/Manuell)
10	Sensor	PV-Leistung (W)
11	Sensor	Temperatur (°C)
12	Sensor	Luftfeuchte (%)

Cayenne-Dashboard einrichten

1. Account auf cayenne.mydevices.com erstellen.
2. „Bring Your Own Thing“ wählen → MQTT-Credentials (Username, Password, Client ID) kopieren.
3. Credentials in den Sketch eintragen, kompilieren, auf Arduino Mega hochladen.
4. Seriellen Monitor öffnen → Verbindungslog prüfen.
5. Im Dashboard: „Add new → Device/Widget → Custom Widgets“ für jeden Kanal passendes Widget wählen (Value für Sensoren, Slider für Servos, Button für Modus).
6. Optional: Triggers (Alarme) anlegen, z. B. „Temperatur > 50 °C → E-Mail senden“.

Prototyp & Ergebnisse

Der Aufbau zeigt Panel, beide Servos, LDRs in Hülsen, DHT22, Ethernet-Shield und Verkabelung. Die Hülsen sorgen dafür, dass bei schrägem Lichteinfall Schatten auf die LDRs fallen – die Regelung strebt gleichmäßige Beleuchtung aller vier Sensoren an.

Detaillierte Messergebnisse und wissenschaftliche Auswertung finden sich im Paper: Springer Link.

Kompletter Arduino-Code

/***************************************************************
 * IoT-basierter Solartracker – Embedded Software
 * 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);

// MQTT-Credentials (beim Cayenne-Dashboard generieren)
char username[] = "DEIN_USERNAME";
char password[] = "DEIN_PASSWORD";
char clientID[] = "DEIN_CLIENT_ID";

Servo servo_x; // Vertikal (U-D)
int servoh = 0, servohLimitHigh = 170, servohLimitLow = 10;
Servo servo_z; // Horizontal (L-R)
int servov = 0, servovLimitHigh = 170, 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);
  servo_z.attach(6);
  dht.begin();
  pinMode(3, OUTPUT);
  digitalWrite(3, LOW); // Start: Manuell
}

void loop() {
  // LDRs einlesen
  topr = analogRead(A2);
  topl = analogRead(A3);
  botl = analogRead(A4);
  botr = analogRead(A5);
  Vout = (analogRead(A1) * 5.0) / 1023.0;

  Cayenne.loop(); // MQTT-Kommunikation & Widget-Handling

  if (digitalRead(3) == HIGH) { // Automatisch-Modus
    Serial.println("Automatic-mode");
    servoh = servo_x.read();
    servov = servo_z.read();

    int avgtop = (topr + topl) / 2;
    int avgbot = (botr + botl) / 2;
    int avgright = (topr + botr) / 2;
    int avgleft = (topl + botl) / 2;

    int diffhori = avgtop - avgbot;   // Vertikalachse
    int diffverti = avgleft - avgright; // Horizontalachse

    // Vertikal (U-D)
    if (abs(diffhori) <= threshold_value) {
      servo_x.write(servoh);
    } else if (diffhori > threshold_value) {
      servo_x.write(servoh - 2); // CW
      if (servoh > servohLimitHigh) servoh = servohLimitHigh;
      delay(10);
    } else {
      servo_x.write(servoh + 2); // CCW
      if (servoh < servohLimitLow) servoh = servohLimitLow;
      delay(10);
    }

    // Horizontal (L-R)
    if (abs(diffverti) <= threshold_value) {
      servo_z.write(servov);
    } 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);
    }
  }
}

// --- Cayenne Callback-Funktionen ---

// Modus-Button (Kanal 8)
CAYENNE_IN(8) {
  int value = getValue.asInt();
  digitalWrite(3, value); // LED & Modus-Flag setzen
}

// Vertikal-Servo manuell (Kanal 7)
CAYENNE_IN(7) {
  if (digitalRead(3) == LOW) { // Nur im Manuell-Modus
    servo_x.write(getValue.asDouble() * 180);
  }
}

// Horizontal-Servo manuell (Kanal 6)
CAYENNE_IN(6) {
  if (digitalRead(3) == LOW) {
    servo_z.write(getValue.asDouble() * 180);
  }
}

// Sensoren → Cloud
CAYENNE_OUT(0) { // Strom
  float current = Vout / 10.0;
  Cayenne.virtualWrite(0, current);
}
CAYENNE_OUT(1) { // Spannung
  float voltage = Vout * 2.0;
  Cayenne.virtualWrite(1, voltage);
}
CAYENNE_OUT(2) { Cayenne.virtualWrite(2, topr); } // LDR Top-R
CAYENNE_OUT(3) { Cayenne.virtualWrite(3, topl); } // LDR Top-L
CAYENNE_OUT(4) { Cayenne.virtualWrite(4, botl); } // LDR Bot-L
CAYENNE_OUT(5) { Cayenne.virtualWrite(5, botr); } // LDR Bot-R
CAYENNE_OUT(10) { // Leistung
  float power = (Vout * 2.0 * Vout) / 10.0;
  Cayenne.virtualWrite(10, power);
}
CAYENNE_OUT(11) { // Temperatur
  float t = dht.readTemperature();
  Cayenne.virtualWrite(11, t, TYPE_TEMPERATURE, UNIT_CELSIUS);
}
CAYENNE_OUT(12) { // Feuchte
  float h = dht.readHumidity();
  Cayenne.virtualWrite(12, h);
}

Schaltplan

Die Datei 2021122810483144.png zeigt den vollständigen Verdrahtungsplan (Fritzing/Schema).

Fazit & Ausblick

Das System demonstriert kostengünstiges IoT-Monitoring und -Steuerung für Photovoltaik. Erweiterungen könnten MPPT-Laderegler, Datenspeicherung auf SD-Karte, LoRa/WiFi statt Ethernet oder KI-basierte Vorhersage der Sonnenbahn umfassen.