Introduction
Le suivi du soleil avec un panneau solaire permet de maximiser l’efficacité énergétique en orientant toujours le panneau face au soleil. Dans cet article, nous allons voir comment réaliser un système de suivi solaire à l’aide d’une carte Arduino pour contrôler les moteurs et les capteurs de lumière, et une Raspberry Pi pour gérer l’alimentation, la surveillance et le stockage de l’énergie.
Niveau de difficulté : 4/5
Matériel Nécessaire
– Panneau solaire (50W ou plus)
– Arduino Uno ou tout autre modèle compatible
– Raspberry Pi (modèle 3B+ ou 4 recommandé)
– Servomoteurs (x2) pour les axes X et Y
– Capteurs de lumière (LDR – Light Dependent Resistor) (x4)
– Module RTC (Real Time Clock) pour Arduino
– Régulateur de tension (Step-Down et Step-Up)
– Batterie de stockage (Li-ion 12V)
– Contrôleur de charge solaire
– Fils de connexion et plaques de prototypage
– Résistances (10kΩ pour les LDR)
– Connecteurs pour batterie
– Modules de relais pour la gestion de l’alimentation
– Module WiFi (optionnel) pour la gestion à distance (pour Raspberry Pi)
– Fer à souder et de l’étain
Schéma de Connexion
1. Arduino avec les LDR et Servomoteurs :
– Connectez les quatre LDR aux entrées analogiques A0 à A3 de l’Arduino, chaque LDR étant associé à une résistance de 10kΩ en série pour former un diviseur de tension.
– Connectez les deux servomoteurs aux broches PWM (D9 et D10) de l’Arduino.
– Ajoutez le module RTC à l’Arduino via les broches I2C (SDA, SCL).
2. Raspberry Pi avec l’Arduino et l’alimentation :
– Connectez l’Arduino à la Raspberry Pi via USB pour la communication série.
– Utilisez des modules de relais pour gérer l’alimentation de l’Arduino, des capteurs et des servomoteurs depuis la Raspberry Pi.
– Connectez le panneau solaire au contrôleur de charge solaire, puis à la batterie de stockage.
– Connectez la Raspberry Pi et l’Arduino au régulateur de tension pour alimenter les deux dispositifs correctement.
Code pour Arduino
Le code suivant lit les valeurs des capteurs de lumière et contrôle les servomoteurs pour orienter le panneau solaire.
#include <Servo.h>
#include <Wire.h>
#include <RTClib.h>RTC_DS3231 rtc;
Servo servoX;
Servo servoY;const int ldrPin1 = A0; // Capteur en haut à gauche
const int ldrPin2 = A1; // Capteur en haut à droite
const int ldrPin3 = A2; // Capteur en bas à gauche
const int ldrPin4 = A3; // Capteur en bas à droiteint posX = 90; // Position initiale
int posY = 90;void setup() {
servoX.attach(9);
servoY.attach(10);Serial.begin(9600);
if (!rtc.begin()) {
Serial.println(« Couldn’t find RTC »);
while (1);
}if (rtc.lostPower()) {
rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
}servoX.write(posX);
servoY.write(posY);
}void loop() {
int val1 = analogRead(ldrPin1);
int val2 = analogRead(ldrPin2);
int val3 = analogRead(ldrPin3);
int val4 = analogRead(ldrPin4);int avgTop = (val1 + val2) / 2;
int avgBottom = (val3 + val4) / 2;
int avgLeft = (val1 + val3) / 2;
int avgRight = (val2 + val4) / 2;if (abs(avgTop – avgBottom) > 50) {
if (avgTop > avgBottom) {
posY = min(posY + 1, 180);
} else {
posY = max(posY – 1, 0);
}
}if (abs(avgLeft – avgRight) > 50) {
if (avgLeft > avgRight) {
posX = max(posX – 1, 0);
} else {
posX = min(posX + 1, 180);
}
}servoX.write(posX);
servoY.write(posY);
delay(1000);
}
Code pour Raspberry Pi
La Raspberry Pi gère l’alimentation et fournit une interface de gestion à distance. Nous utiliserons Python pour cette partie.
1. Installation des bibliothèques nécessaires :
sudo apt-get update
sudo apt-get install python3-pip
pip3 install RPi.GPIO smbus2 Flask
2. Script Python pour gérer l’alimentation et la communication avec l’Arduino :
import RPi.GPIO as GPIO
from smbus2 import SMBus
from flask import Flask, render_template, jsonify
import serial
import time# Configuration des broches GPIO pour les relais
RELAY_PIN = 17
GPIO.setmode(GPIO.BCM)
GPIO.setup(RELAY_PIN, GPIO.OUT)# Activer le relais pour allumer l’Arduino
GPIO.output(RELAY_PIN, GPIO.HIGH)# Communication série avec l’Arduino
ser = serial.Serial(‘/dev/ttyUSB0’, 9600)# Flask app
app = Flask(__name__)# Variables globales
posX = 90
posY = 90
light_percent = 0
battery_percent = 0
light_intensity = 0
power_usage = 0# Fonction pour surveiller l’état de la batterie
def monitor_battery():
global battery_percent
with SMBus(1) as bus:
# Exemple pour lire les informations de la batterie
# Remplacer par le code spécifique au contrôleur de charge utilisé
battery_percent = 50 # Valeur simulée# Fonction pour surveiller l’intensité lumineuse
def monitor_light():
global light_percent, light_intensity
light_percent = 75 # Valeur simulée
light_intensity = 800 # Valeur simulée en lux# Fonction pour surveiller la consommation électrique
def monitor_power():
global power_usage
power_usage = 10 # Valeur simulée en watts# Endpoint Flask pour obtenir les données en temps réel
@app.route(‘/data’)
def data():
return jsonify({
‘posX’: posX,
‘posY’: posY,
‘light_percent’: light_percent,
‘light_intensity’: light_intensity,
‘battery_percent’: battery_percent,
‘power_usage’: power_usage
})@app.route(‘/’)
def index():
return render_template(‘index.html’)if __name__ == ‘__main__’:
app.run(host=’0.0.0.0′, port=5000)while True:
monitor_battery()
monitor_light()
monitor_power()
time.sleep(60) # Vérifier chaque minute
Template HTML (`templates/index.html`)
Ce template affiche les données en temps réel et permet de surveiller le système de suivi solaire.
<!DOCTYPE html>
<html lang= »en »>
<head>
<meta charset= »UTF-8″>
<title>Gestion Panneau Solaire</title>
<style>
body { font-family: Arial, sans-serif; }
h1 { text-align: center; }
.container { display: flex; justify-content: center; }
.card { border: 1px solid #ccc; border-radius: 8px; padding: 16px; margin: 16px; }
.card h2 { margin-top: 0; }
</style>
</head>
<body>
<h1>Gestion du Panneau Solaire</h1>
<div class= »container »>
<div class= »card »>
<h2>Position des axes</h2>
<p>X: <span id= »posX »>90</span>°</p>
<p>Y: <span id= »posY »>90</span>°</p>
</div>
<div class= »card »>
<h2>Intensité lumineuse</h2>
<p>% de lumière: <span id= »light_percent »>0</span>%</p>
<p>Quantité de lumière: <span id= »light_intensity »>0</span> lux</p>
</div>
<div class= »card »>
<h2>Niveau de la batterie</h2>
<p>% de charge: <span id= »battery_percent »>0</span>%</p>
</div>
<div class= »card »>
<h2>Consommation électrique</h2>
<p>Usage en temps réel: <span id= »power_usage »>0</span> W</p>
</div>
</div><script>
async function fetchData() {
const response = await fetch(‘/data’);const data = await response.json();
document.getElementById(‘posX’).textContent = data.posX;
document.getElementById(‘posY’).textContent = data.posY;
document.getElementById(‘light_percent’).textContent = data.light_percent;
document.getElementById(‘light_intensity’).textContent = data.light_intensity;
document.getElementById(‘battery_percent’).textContent = data.battery_percent;
document.getElementById(‘power_usage’).textContent = data.power_usage;
}setInterval(fetchData, 1000); // Actualiser toutes les secondes
</script>
</body>
</html>
Conclusion
En suivant ces étapes, vous pouvez créer un système de panneau solaire suiveur de soleil contrôlé par une carte Arduino et une Raspberry Pi. Ce projet maximise l’efficacité énergétique de votre panneau solaire, permet une gestion à distance pratique et vous fournit des informations détaillées sur la performance du système. N’hésitez pas à expérimenter et à ajuster les paramètres pour optimiser les performances de votre système. Bonne chance !