Document ID: /fineweb-2-swissfilter-quality_10-filterrobots/filtered/07201.jsonl.gz/412

20H — SUNFLOWERbot
L'objectif de ce projet est de réaliser un panneau solaire photovoltaïque orientable.
Quatre capteurs de luminosité calculent le déplacement qu'un socle doit effectuer afin de positionner de façon optimale le panneau solaire photovoltaïque, c'est à dire de l'orienter perpendiculairement au rayonnement solaire. Le déplacement du panneau sur les axes horizontal et vertical est assuré par deux servomoteurs.
Aujourd'hui, le panneau solaire orientable est peu répandu, car il s'agit d'un système relativement complexe, donc cher. Un panneau orientable est cependant beaucoup plus perfomant qu'un panneau fixe. Grâce à une amélioration et une optimisation du support, des composants électroniques et du programme utilisé, le panneau orientable pourrait s'imposer comme la solution d'avenir. Il s'agirait d'une évolution majeure, succeptible d'augmenter significativement le rendement de la production photovoltaique. Nous nous intéressons donc à un concept encore en cours de développement mais très prometteur.
Ce projet a été réalisé par Alexandre PFYFFER dans le cadre du cours d'OC Informatique.
Figure 0 : SUNFLOWERbot
1. Introduction
L’énergie solaire photovoltaïque est renouvelable car sa source – le soleil – ne s’épuise pas à notre échelle. Les panneaux photovoltaïques utilisent l’énergie lumineuse (les photons) du soleil pour produire de l’électricité. Ce phénomène physique et chimique s’appelle l’effet photovoltaïque.
Figure 1 : panneaux solaires photovoltaïques fixes montés sur un toit
En 1839, le physicien français Edmond Becquerel observe la capacité de certains matériaux à créer un potentiel électrique à partir de la lumière émise par le soleil. Ces expériences avaient pour but de mesurer l’intensité lumineuse. Ce n’est que en 1881 que l’ingénieur Américain Charles Fritts invente et produit le premier panneau solaire commercial. Ce ne fut pas une grande réussite car les centrales à charbon étaient bien plus rentables à cette époque.
Aujourd’hui, en Suisse, la production d’électricité provenant de panneaux solaires photovoltaïques est encore relativement modeste. En 2017 elle ne représentait que environ 3 % de la production totale d’électricité. Le graphique suivant illustre bien cela.
Figure 2 : statistique représentant le pourcentage d’électricité des différents moyens de production en Suisse en 2017
Il faut cepandant noter que cette production se développe de façon très importante. Au rythme de croissance actuel, on estime par exemple qu'elle devrait doubler dans les quatre ans à venir (voir article RTS).
Un tracker solaire est un engin qui oriente le panneau solaire dans la position optimale par rapport au rayonnement solaire. Il en existe différentes versions : certaines rudimentaires s’orientent sur un axe et d’autres plus perfectionnées sur deux axes. De plus, certains programmes suivent une inclinaison préprogrammée et d’autres captent en temps réel l’inclinaison des rayonnements solaires. L'avantage de ces derniers est qu'ils peuvent être implantés dans n'importe quelle position géographique. Un tracker solaire augmente significativement le rendement du panneau solaire. La difficulté est que l'augmentation du rendement doit couvrir l'augmentation du coût de l'installation. Dans la réalité il faut aussi tenir compte du coût de la maintenance qui peut s'avérer très élevé.
Figure 3 : module mobile sur deux axes - centrale photovoltaïque de Qingdao, Chine
L'objectif de ce projet est de réaliser un panneau solaire photovoltaïque orientable. Nous l'avons nommé SUNFLOWERbot car nous nous inspirons des tournesols et de leur fascinante capacité à s'orienter vers le soleil.
La partie Hardware est la première phase du projet. Le socle du panneau doit être construit pour supporter le poids du panneau solaire, des quatre capteurs et du raspberry. Les deux servomoteurs doivent donc être assez robustes et fiables.
La partie Software est la deuxième partie du projet. Elle consiste à créer un programme en python gérant le fonctionnement du tracker. Étant un ‘proof of concept’ le module devra être fonctionnel par beau temps.
Ce programme peut être lent et évidement très peu énergivore afin d’augmenter le rendement du module. La position sur les deux axes doit être très précise pour assurer un rendement optimal du module.
Nous espérons obtenir un tracker solaire précis et fiable permettant un ‘proof of concept’. Ce but semble possible dans le temps imparti.
2. Matériel et méthodes
Voici le matériel utilisé lors du projet :
2.1 Hardware
1x plateau de bois aggloméré (35x30x0,3 cm)
1x latte de bois (45x6x1,5 cm)
1x bloc de bois (15x5,5x3,5 cm)
1x bloc de bois (17x5,5x3,5 cm)
2x bloc de bois (3x2x1,5 cm)
8x clou (1x0,1 cm)
11x clou (2,5x0,15 cm)
1x support de montage en aluminium Reely FS9020C
1x servo horn (palonnier) set contenant les vis adaptées
2x tige métallique rigide
1x contrepoids
4x élastique
1x scotch double-face
2.2 Software
1x panneau solaire Nomad 7plus 7-WATT
1x ordinateur
1x raspberry Pi 3 Model
1x 16-channel PWM/Servo HAT
4x VL6180X ambient light sensor
2x Hitec HS-311 servomoteur
1x carte micro SD
1x Clavier et souris USB
1x cable HDMI
1x AC to 6 V DC adapter
1x cable alimentation raspberry
1x bread board (60 x 12)
1x mini bread board (18 x 12)
18x Fil de cuivre (diamètre extérieur 1 mm) (longueur 14 cm) cosse mâle - mâle
2.3 Outils
1x marteau
1x scie à bois manuelle
1x boite de tournevis en croix
1x fer à souder (avec fil d'étain)
1x support de plaque pour soudure
3 Méthode
3.1 Hardware
3.1.1 Concept
Le but recherché est de pouvoir faire tourner le module très précisément et avec le moins de résistance possible (frottements) sur l’axe horizontal et vertical. La solution choisie est de fixer un servomoteur sur un socle tournant dont l’axe est maintenu par un roulement à bille. Le deuxième servomoteur pour l’axe vertical est fixé à l’extrémité du ‘U’ formé par le socle en bois. Le plateau est maintenu d’un coté du ‘U’ par le servomoteur et de l’autre côté par un clou fixé dans le bloc de bois.
3.1.2 Socle tournant travaillant sur l’axe horizontal (support de montage en aluminium Reely FS9020C)
Figure 4 : socle tournant, vue de dessous
Dévisser la vis en dessous de l’axe central, insérer un palonnier de servomoteur et revisser la vis. Fixer un autre palonnier de servomoteur au servomoteur. Visser les deux palonniers ensemble avec quatre vis du kit de palonnier. Afin de tenir le servomoteur en place, le fixer avec les deux tiges métalliques rigides.
3.1.3 Support en bois en forme de ‘U’ et plateau travaillant sur l’axe vertical
Figure 5.1 : Support en bois en forme de ‘U’ et plateau
Couper les bouts de bois aux dimensions indiqués dans la liste de matériel. Fixer les deux blocs de bois aux extrémités de la latte de bois avec six clous. Fixer le servomoteur au sommet du bloc de bois de 15 cm de haut avec quatre clous. Fixer les deux petits blocs de bois aux deux centres des cotés de 35 cm du plateau de bois. Clouer un palonnier sur un des petits blocs de bois et clouer un grand clou sur l’autre petit bloc de bois. Fixer le plateau de bois entre les deux côtés du ‘U’.
Figure 5.2 : servomoteur vertical et palonnier fixé au plateau
3.2 Software
Pour toute la programmation, nous programmons directement depuis le Raspberry sur l’application Thonny. Il faut donc brancher l’écran, le clavier, la souris et le câble d’alimentation au Raspberry.
3.2.1 Test des servomoteurs et du servo Hat
Fixer le servo Hat sur le Raspberry, l’alimenter et brancher les deux servomoteurs. Enclencher l’I2C sur le Raspberry et contrôler que la librairie Adafruit_Blinka est installée. Installer la librairie suivant depuis le terminal :
sudo pip3 install adafruit-circuitpython-servokit
Lancer le programme suivant plusieurs fois en changeant l’angle (en degrés) afin de tester les servomoteurs :
import time from adafruit_servokit import ServoKit kit = ServoKit(channels=16) kit.servo[0].angle = 180 time.sleep(1) kit.servo[0].angle = 0 time.sleep(1)
Les deux servomoteurs doivent fonctionner.
3.2.2 Test des quatre capteurs de luminosité
Fixer les capteurs sur la bread board de la façon suivante :
GPIO (4 différents) du Raspberry au VIN du capteur GND du Raspberry au GND du capteur SCL du Raspberry au SCL du capteur SDA du Raspberry au SDA du capteur
Figure 6 : test des quatre capteurs de luminosité
Installer les trois librairies suivantes :
adafruit_vl6180x.mpy
adafruitbusdevice
sudo pip3 install adafruit-circuitpython-vl6180x
Lancer le programme suivant, avec chaque capteur individuellement, en branchant le VIN du capteur au 3.3V du Raspberry :
import time import board import busio import adafruit_vl6180x # Create I2C bus. i2c = busio.I2C(board.SCL, board.SDA) # Create sensor instance. sensor = adafruit_vl6180x.VL6180X(i2c) # Main loop prints the range and lux every second: while True: light_lux = sensor.read_lux(adafruit_vl6180x.ALS_GAIN_1) print('Light (1x gain): {0}lux'.format(light_lux)) time.sleep(1.0)
Ce programme permet de contrôler le bon fonctionnement des quatre capteurs.
Ensuite fixer les quatre capteurs sur la petite bread board et la fixer à l’avant du support en bois. Attacher avec du scotch double-face le Raspberry et la grande bread board à l’arrière du support en bois.
Figure 7 : composants fixés à l’arrière du support en bois
Figure 8 : composants fixés à l’avant du support en bois
3.2.3 Panneau solaire
Attacher le panneau solaire avec quatre élastiques à l’avant du support en bois et sa sortie USB à l’arrière du support.
3.3 Montage et programme final
Le montage final ressemble à la photo ci-dessous :
Figure 9 : montage final
Nous ne reproduisons pas la totalité du programme final (il fait 200 lignes). Nous nous contentons d'expliquer ses parties les plus importantes.
Voici les librairies importées (que nous avons déjà présentées lors des programmes de test ci-dessus) :
# SUNFLOWERbot - Projet H 2020 - Alexandre PFYFFER # Programme qui permet au panneau solaire orientable de se placer perpendiculairement aux rayons du soleil # remarque : la precision des resultats est imortante afin d'orienter le panneau solaire de façon optimale # la vitesse d'execution du programme n'est pas importante, le soleil ne change pas rapidement d'orientation import time import board import busio import adafruit_vl6180x import RPi.GPIO as GPIO from time import sleep from adafruit_servokit import ServoKit kit = ServoKit(channels=16)
Ensuite, on fixe les variables. Par la suite, celles-ci pourront être facilement modifiées lors des tests.
# Parametres #ports GPIO 18 a 24 potentiellement utilisables #(ports 25-26-27 defectueux sur raspberry grimsvotn) port_debut=18 port_fin=24 #tableau : 4 sorties gpio pour capteurs intensite lumineuse #20 - bas gauche / 21 - haut gauche / 22 - haut droite / 23 - bas droite port_module=(20,21,22,23) #calibration lecture capteur, si cal positif => valeur corrigee vers le bas cal_module=(0,0,0,0) #delai de reveil du module, risque bug si trop petit delai_reveil_module=0.1 #delai entre mesure du capteur (pour obtenir moyenne) delai_mesures_modules=0.05 #nombre de mesures pour etablir la moyenne nb_mesures_lum=5 #intervalle entre mouvements des servomoteurs en secondes en présence de "soleil" intervalle_soleil=2 #intervalle entre mouvements des servomoteurs en secondes en présence de "nuages" intervalle_nuage=30 #intensite minimale moyenne d'un capteur pour que le panneau s'oriente lux_min=4 #angle innitial des servomoteurs en degres angle_inni_servo_horiz=90 angle_inni_servo_vert=135 #attribution des bancs de modules droit=(2,3) gauche=(0,1) haut=(1,2) bas=(0,3) #seuil definissant "l'incertitude" en lux => pas mouvement servomoteurs seuil_lum_vert=40 seuil_lum_horiz=40 #si debug = 1 imprime etat des ports gpio debug=0
Les quatre capteurs de luminosité, alimentés par quatre pins GPIO différents, sont alimentés l’un après l’autre. Voici la partie du programme concernée :
# Initialisations ## création du bus I2C i2c = busio.I2C(board.SCL, board.SDA) #----------------------------------------# # Initialisation des ports GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) #ports GPIO 18 a 24 defini comme sortie, initiallement ferme for port in range (port_debut,port_fin+1): GPIO.setup(port, GPIO.OUT) GPIO.output(port, False) if debug == 1: print ("Init port : ",port) #----------------------------------------# #fonction qui defini l'etat d'un port en fonction de state def gpio_onoff(port,state): GPIO.output(port, state) if debug == 1: print("Etat port :",port," : ",state) #----------------------------------------# #fonction defini etat module pour tableau def power(module,state): if state == "on": state=True elif state == "off": state=False else: print("Erreur fonction power") if debug == 1: print ("Etat module ",module," : ",state) gpio_onoff(port_module[module],state)
Lorsqu’un capteur est enclenché, il prend un nombre (défini par le programme) de mesures de luminosité en Lux. Afin de garantir une bonne précision, il fait une moyenne de ces valeurs. Il en découle une valeur d’intensité lumineuse par capteur. Voici la partie du programme concernée pour un ‘module’ (capteur) :
def lecture_module(module): power(module,"on") sleep(delai_reveil_module) ## Create sensor instance. sensor = adafruit_vl6180x.VL6180X(i2c) echantillon=0 for i in range (0,nb_mesures_lum): echantillon += sensor.read_lux(adafruit_vl6180x.ALS_GAIN_1) sleep(delai_mesures_modules) mesure=echantillon/nb_mesures_lum power(module,"off") return mesure-cal_module[module]
Pour calculer le déplacement du servomoteur sur l’axe horizontal, la valeur des deux capteurs de gauche moins la valeur des deux capteurs de droite donnera un résultat. Si ce résultat est positif et ‘de valeur absolue assez grande’, le panneau tournera vers la gauche. Si ce résultat est positif et ‘de valeur absolue assez grande’, le panneau tournera vers la droite. Si ce résultat est de valeur absolue trop petite (défini dans le programme), le servomoteur maintiendra sa position.
Remarque : les tableaux créés au début du programme permettent de comprendre quel module est appelé dans chaque cas
#fonction qui calcule de la différence entre valeurs des 2 capteurs gauches et droits def info_lum_horiz(): banque_droite=lecture_module(droit[0])+lecture_module(droit[1]) banque_gauche=lecture_module(gauche[0])+lecture_module(gauche[1]) eclair_horiz=banque_droite-banque_gauche return eclair_horiz #fonction qui convertit la difference horizontale en trois valeurs 1, -1, 0 def info_lum_horiz_tristate(): valeur=info_lum_horiz() if valeur > seuil_lum_horiz: sortie=-1 elif valeur < -seuil_lum_horiz: sortie=1 else: sortie=0 return sortie
Le même procédé est utilisé pour l’axe vertical.
Voici la partie importante de la boucle principale qui reprend le résultat de plusieurs fonctions définies auparavant.
#boucle principale while True: #si intensité lumineuse en dessous du min, attendre intervalle nuage (et reprendre position innitiale) if test_presence_soleil() == 0: sleep(intervalle_nuage) #si intensité lumineuse au dessus du min, le panneau s'oriente en fontion du soleil elif test_presence_soleil() == 1: if 5 < valeur_servo_horiz < 175 and 95 < valeur_servo_vert < 175 : valeur_servo_horiz += info_lum_horiz_tristate() * 5 print(valeur_servo_horiz) valeur_servo_vert += info_lum_vert_tristate() * 5 print(valeur_servo_vert) kit.servo[0].angle = valeur_servo_horiz kit.servo[1].angle = valeur_servo_vert sleep(intervalle_soleil)
Si la moyenne des valeurs des quatre capteurs de luminosité est en dessous d’un minimum, le programme se met en veille pour un temps prolongé.
Finalement, l’angle des deux servomoteurs ne doit pas dépasser des valeurs limites.
Remarque : voir le programme entier pour plus de détails
4 Résultats
Le panneau fonctionne avec une précision suffisante pour un 'proof of concept'. Il s’oriente correctement en une ou deux minutes ce qui est assez rapide.
Lors d'une expérience à l'extérieur, le module a suivi la course du soleil pendant plus de deux heures, en orientant le panneau sur les deux axes par des incréments de 5°.
Figure 10 : SUNFLOWERbot en action (accéléré 10x)
5 Discussion
Même si la précision de l'orientation du panneau est satisfaisante, l’utilisation de capteurs plus précis aurait permis de l'améliorer encore.
Les capteurs de luminosité ont posé un problème. Ils fonctionnent sur le port I2C et ont une même adresse non modifiable. Après réflexion et une perte de temps conséquente, nous avons décidé d’allumer un capteur après l’autre en les alimentant avec des ports GPIO. La rapidité n’est pas importante pour notre programme, cette solution était donc la plus avantageuse.
Le programme ne s’est de loin pas avéré fonctionnel du premier coup. Il a d’abord fallu tester les capteurs de luminosité sur plusieurs ports GPIO, ce qui nous a amené à la conclusion que certains ports sont défectueux sur notre Raspberry.
Le calibrage des servomoteurs a posé quelques problèmes. Afin de ne pas abimer les servomoteurs, nous avons défini au lancement du programme l’angle initial des servomoteurs afin de contrôler leur inclinaison.
L’utilisation de quatre capteurs de luminosité s’est avérée adéquate pour ce projet, mais d'autres concepts sont possibles :
Nous aurions pu utiliser un seul capteur. Cela permet de diviser par quatre le nombre de capteur et donc de baisser le coût du matériel. Par contre cela nécessite de régulier 'balayage' sur les deux axes pour déterminer la position optimale du panneau. Les servomoteurs auraient dû faire de très nombreux déplacements inutiles, ce qui présente beaucoup d'inconvénients (consommation, usure, mauvaise orientation pendant le 'balayage').
Plutôt que d'utiliser des capteurs de luminosité, nous aurions aussi pu mesurer le potentiel électrique produit par le panneau solaire. Dans ce cas, c'est le panneau solaire lui-même qui sert de capteur. Cela permet d'éliminer les capteurs et donc de baisser le coût du matériel. On est cependant confronté aux mêmes inconvéniants liés au 'balayage'.
Ces solutions ne semblent donc pas meilleures.
Dans le cadre d'une utilisation pratique du panneau solaire orientable, nous pouvons proposer deux idées de développement :
En hiver le rendement chute si le panneau solaire est recouvert de neige. En cas de chute de neige, le programme pourrait mettre le panneau en position verticale pour évacuer la neige. Ce système prend toute sa valeur pour des installations en montagne, là où le rendement est le plus élevé (plus de 40%, voir l'article du WWF).
La grêle est susceptible de détruire les panneaux solaires photovoltaïques. Un tel évènement réduit évidemment à néant tous les calculs de rendements théoriques. Pour éviter cela, le programme pourrait mettre le panneau en position horizontale inversée pour le protéger. Un capteur sysmique monté sur le panneau pourrait donner l'impulsion en détectant la chute de grêle.
6 Conclusion
Le fonctionnement de notre panneau solaire est concluant. Il se positionne de façon presque optimale par rapport aux rayons du soleil. L’objectif est atteint.
Evidemment, pour être commercialisé, un panneau solaire orientable devrait être résistant aux intempéries, fiable et peu énergivore. Ces critères semblent être difficiles à atteindre. Mais en réalité, les panneaux solaires orientables existent déjà. Ils sont utilisés dans plusieurs pays, par exemple en Chine (voir Figure 3) et ils remplissent les critères mentionnés ci-dessus. Nous pensons donc que les panneaux solaires orientables sont une solution d'avenir et qu'ils seront de plus en plus répandus dans le futur.
“Tourne-toi vers le soleil, l'ombre sera derrière toi.”
Proverbe maori
Références
Information sur le capteur de luminosité utilisé
https://learn.adafruit.com/adafruit-vl6180x-time-of-flight-micro-lidar-distance-sensor-breakout/overview
https://cdn-learn.adafruit.com/downloads/pdf/adafruit-vl6180x-time-of-flight-micro-lidar-distance-sensor-breakout.pdf?timestamp=1579953721
Information sur le servo Hat utilisé
https://learn.adafruit.com/adafruit-16-channel-pwm-servo-hat-for-raspberry-pi/overview
Information sur les ports GPIO
https://www.raspberrypi.org/documentation/usage/gpio/
Information sur l’I2C
https://learn.adafruit.com/adafruits-raspberry-pi-lesson-4-gpio-setup/configuring-i2c
Information sur la programmation en langage python
https://python.doctor/
https://wiki.python.org/moin/ForLoop
https://www.programiz.com/python-programming/time/sleep
https://www.programiz.com/python-programming/function
https://snakify.org/fr/lessons/forlooprange/
https://www.thegeekstuff.com/2013/08/python-array/
Information sur les panneaux solaires photovoltaïques et les trackers solaires
https://www.futura-sciences.com/planete/dossiers/developpement-durable-cellules-photovoltaiques-coeur-panneaux-solaires-1688/page/4/
https://www.rts.ch/info/economie/10474652-le-photovoltaique-pese-deja-40-milliards-et-devrait-doubler-en-4-ans.html
https://www.wwf.ch/fr/nos-objectifs/energie-solaire
https://www.okwind.fr/trackers.html
https://www.hisour.com/fr/solar-tracker-39716/
Images
Figure 1 : Photovoltaik Dachanlage Hannover - Schwarze Heide - Leistung 1 MW, AleSpa, 10 July 2012
Figure 2 : https://www.kernenergie.ch/fr/le-mix-electrique-suisse-_content
-11069.html
Figure 3 : 200kW dual axis tracker with CPV modules in Qingdao, China, Vinaykumar8687, 4 March 2011