CHAINE D’ACQUISITION DE

DONNEES

Projet sur :
Suiveur Solaire

Encadré par :

Mr .ElRharrass Abdessamad

Réalisé par :

ELHANI Houda

BEN ABDELOUAHAB Nouhaila

Haloua Mohamed
 Remerciement

L a réalisation de ce travail s’est concrétisée grâce au soutien de plusieurs

personnes à qui nous voudrions témoigner toutes nos gratitudes.

Nous adressons nos sincères remerciements à tous le cadre administratif et

professoral de L’Ecole Hassania des Travaux Publiques et spécialement le
département Génie Électrique pour le travail énorme qu’ils effectuent afin de
créer les conditions les plus favorables pour le déroulement de nos études.

Nos sincères remerciements, vont à Mr. JANYENE le chef de département Génie

Électrique pour ses efforts, soutiens et gentillesses, nous ayant permis
d’accomplir nos travaux dans les meilleures conditions.

Ainsi, nous tenons à exprimer nos profondes gratitudes à Mr. EL RHERRAS

Abdessamad pour son encadrement, son suivi quotidien qu’il a consacré pour
veiller au bon déroulement de notre projet.

Nous tenons enfin, à travers ces mots, à remercier très chaleureusement toutes
les personnes qui par leurs paroles, leurs écrits, leurs conseils et leurs critiques
ont permis la réalisation de notre projet de classe.

1
 Tables des matières
Introduction générale………………………………………………………………………………………………………………………..6

Chapitre 1 : Présentation du projet ……………………………………………………………………………………………………7

1 Introduction ................................................................................................................................7
2 Objectif principal du projet..........................................................................................................7
3 Objectif secondaire du projet ......................................................................................................8
4 Conclusion ..................................................................................................................................8
Chapitre 2 : Présentation du projet………………………………………………………………………………………………..…10

1 Matériels.....................................................................................................................................9
1.1 Arduino Uno ........................................................................................................................9
1.2 Carte Arduino Mega .......................................................................................................... 13
1.3 LCD .................................................................................................................................... 14
1.4 Servomoteur ..................................................................................................................... 14
1.5 Moteur pas à pas : Stepper ................................................................................................ 15
1.5.1 Principe de commande d’un moteur pas à pas ........................................................... 16
1.6 L293D ................................................................................................................................ 16
1.7 Capteurs ............................................................................................................................ 17
1.7.1 LDR ............................................................................................................................ 17
1.7.2 LM35 ......................................................................................................................... 18
1.7.3 MPX4115 ................................................................................................................... 19
1.7.4 DHT11........................................................................................................................ 20
2 Logiciels .................................................................................................................................... 22
2.1 Arduino ............................................................................................................................. 22
2.2 Proteus .............................................................................................................................. 22
2.3 LABVIEW ........................................................................................................................... 22
2.3.1 Programmation flot de contrôle ................................................................................. 23
2.3.2 Programmation flot de données................................................................................. 23
Chapitre 3 : Conception et simulation……………………………………………………………………………………………...25

1 Description du circuit ................................................................................................................ 24

1.1 LDR .................................................................................................................................... 24

2
 1.2 LCD .................................................................................................................................... 25
1.3 Servomoteur ..................................................................................................................... 25
1.4 LM35 ................................................................................................................................. 25
1.5 MPX4115 ........................................................................................................................... 25
2 Programmation Arduino............................................................................................................ 25
2.1 Circuit 1 : servomoteur commandé par une LDR ................................................................ 26
2.2 Circuit 2 : deux servomoteurs commandés par un LDR....................................................... 27
2.3 Circuit 3 : deux servomoteurs commandés par 4 LDR ......................................................... 27
2.4 Circuit 4 : deux moteurs pas à pas commandés par 4 LDR .................................................. 29
3 SIMULATION ............................................................................................................................. 30
3.1 Circuit 1 : Servomoteur commandé par une LDR ................................................................ 31
3.2 Circuit 2 : Servomoteur Commandé par deux LDR .............................................................. 31
3.3 Circuit 3 : Deux Servomoteurs et 4 photorésistances LDR .................................................. 32
3.4 Circuit 4 : 2 Moteur pas à pas Stepper et 4 LDR .................................................................. 35
4 Cahier de charge et représentation en LABVIEW ....................................................................... 36
4.1 Algorithme LABVIEW ......................................................................................................... 37
Conclusion générale………………………………………………………………………………………………………………………...39

3
 Table des figures
Figure 1: panneau solaire avec suiveur de soleil ..................................................................................7
Figure 2 : affichage des grandeurs .......................................................................................................8
Figure 3 : Carte arduino ......................................................................................................................9
Figure 4 : Description des entrées/sorties de la carte Arduino Mega 2560 ........................................ 13
Figure 5 : Ecran LCD .......................................................................................................................... 14
Figure 6 : Servomoteur ..................................................................................................................... 14
Figure 7 : Bipolaire Stepper ............................................................................................................... 15
Figure 8 : Principe de moteur pas à pas ............................................................................................. 16
Figure 9 : L293D ................................................................................................................................ 16
Figure 10 : Connexions des pins ........................................................................................................ 17
Figure 11 : Caractéristiques électriques de L293D ............................................................................. 17
Figure 12 : LDR .................................................................................................................................. 17
Figure 13 : LM35 ............................................................................................................................... 19
Figure 14 : MPX4115 ......................................................................................................................... 19
Figure 15 : Montage isis .................................................................................................................... 19
Figure 16 : Branches du MPX4115 ..................................................................................................... 19
Figure 17 : la sortie en fonction de la pression absolue ..................................................................... 20
Figure 18 : DHT11 ............................................................................................................................. 20
Figure 19 : circuit électrique du système ........................................................................................... 24
Figure 20 : code du circuit1 ............................................................................................................... 26
Figure 21 : codes du circuit2.............................................................................................................. 27
Figure 22 : codes du circuit3.............................................................................................................. 29
Figure 23 : Algorithme en LABVIEW................................................................................................... 37

4
 Introduction générale
Partout dans le monde, la consommation globale énergétique augmente d’une façon
vertigineuse, et ce au détriment de l’environnement qui nous entoure et dont notre survie en
dépend. En effet, les sources d’énergies fossiles (charbon, pétrole et gaz naturel) sont utilisées
de manière continuellement abusive. Ces dernières, en plus d’être extrêmement polluantes
quand elles subissent un processus de combustion, possèdent des réserves limitées dans le
temps. Ainsi, la communauté scientifique reconnait aujourd’hui la responsabilité de cette
surconsommation sur le réchauffement climatique qui risque d’avoir de dramatiques effets sur
les équilibres physiques, politiques et sociaux-économiques de notre planète. Le recours à des
énergies propres pour assurer la sécurité énergétique et le développement des populations
devient incontournable, et la recherche dans le domaine des ressources d’énergie alternatives
est devenue donc une question cruciale.

Les énergies renouvelables, et particulièrement l’énergie solaire, sont de nos jours la tendance
pour sortir de la dépendance envers les sources fossiles et les problèmes qu’elles provoquent et
que nous venons de citer en haut. Ce choix, motivé par le fait que la quantité d’énergie solaire
reçue chaque jour par la planète est 5 fois supérieure à la totalité des consommations
quotidiennes humaines (nucléaire, charbon, bois, fioul, gaz, hydraulique…) , parait être LA
SOLUTION miracle. Beaucoup de recherches scientifiques ont été menées, non seulement dans
le domaine de la conversion d’énergie solaire en général, mais également dans un secteur bien
particulier de ce dernier, qui n’est d’autre que la technologie photovoltaïque.

Dans ce cas, la conception, l’optimisation et la réalisation des systèmes qui reposent sur cette
technologie sont des problèmes d’actualité puisqu’ils peuvent conduire à une meilleure
exploitation de l’énergie solaire s’ils sont convenablement bien faits. Une des voies empruntées
est celle de l’augmentation du rayonnement solaire capté, puisqu’un maximum d’efficacité est
atteint quand la lumière incidente est perpendiculaire aux cellules des panneaux

5
photovoltaïques : c’est le concept de « suivi solaire ». Donc, l’efficacité énergétique de ces
systèmes dépend du degré d'utilisation et de la conversion du rayonnement solaire. Il y a deux
manières pour maximiser le taux d'énergie utile : en optimisant la conversion et le degré
d’absorption, et en augmentant le taux de rayonnement d'incidence en employant des systèmes
d'orientation mécanique.

C’est dans ce contexte que nous avons décidé, dans notre projet, de réaliser un tel système, et
qui est communément appelle « suiveur solaire » ou « traqueur solaire » Un système de
suivi solaire est une structure qui permet de traquer en temps réel le mouvement apparent du
soleil. Les traqueurs solaires sont conçus et construits pour optimiser le rendement de
puissance des modules PV en s'assurant qu'ils sont perpendiculaires au soleil à tout moment
pendant la journée. Le travail présenté dans ce projet a porté sur l’étude, la conception et la
réalisation d’un tel système.

6
 Chapitre 1 Présentation
du projet
1 Introduction
Face aux risques d’épuisement des ressources en énergie fossile (pétrole, gaz…) ainsi
qu’aux problèmes de changement climatiques, le monde se dirige vers l’exploitation des
énergies renouvelables inépuisables. La science s’est intéressée aux ressources dites
renouvelables et notamment la plus ancienne, le soleil. De nos jours, le soleil est considéré
comme une source d’énergie qu’il nous faut la capter, la transférer et la stocker. La phase de
conversion en électricité est assurée par les panneaux photovoltaïques qui sont exposés à la
source solaire.

2 Objectif principal du projet

Notre objectif dans ce travail est de simuler un suiveur solaire qui va optimiser l’énergie
fournie par les panneaux photovoltaïques en optimisant la quantité d’éclairement absorbée par
les panneaux photovoltaïques à travers le suivi du mouvement de soleil pendant la journée.

Figure 1: panneau solaire avec suiveur de soleil

7
Notre Suiveur solaire est basé sur la programmation d’une carte Arduino qui liera les capteurs
aux actionneurs.

3 Objectif secondaire du projet

Notre objectif secondaire dans ce projet est l’affichage des mesures qui concernent
l’ensoleillement, température et la pression ambiants. A l’aide des capteurs nécessaire pour
capter ces grandeurs nous allons les traiter et les afficher sur un appareil d’affichage choisi
prochainement dans notre réalisation selon le besoin.

Figure 2 : affichage des grandeurs

4 Conclusion
Notre projet a pour objectif d’automatiser le positionnement d’un panneau solaire ainsi que
fournir des données bénéfiques pour l’utilisateur dans son entourage spatial. Ces données
peuvent être utilisées pour l’étude d’un espace.

8
 Chapitre 2
Matériels et logiciels
1 Matériels
1.1 Arduino Uno
Ce sont des cartes électroniques programmables (donc dotées d'un processeur et de
mémoire) sur lesquelles nous pouvons brancher des capteurs de température, d'humidité, de
vibration ou de lumière, une caméra, des boutons, des potentiomètres de réglage, des contacts
électriques…

Figure 3 : Carte arduino

9
 Alimentation / Programmation par USB
La carte Arduino peut être alimentée avec un câble USB relié à
1 votre ordinateur. Tout ce dont vous avez besoin, c’est de
connecter votre carte Arduino à votre ordinateur avec le câble
USB type A/B.
Alimentation via connecteur Jack DC
La carte Arduino peut être directement alimentée par ce
2 connecteur Jack DC. Ce connecteur (2) est relié au régulateur
de tension intégré à la carte. L’alimentation via ce connecteur
(2) doit être comprise entre 5 et 12 V.
Régulateur de tension
La fonction du régulateur de tension (3) est de contrôler la
3
tension d’alimentation de l’Arduino pour la stabiliser à la bonne
tension du microcontrôleur et de chaque élément de la carte. La
tension de stabilisation est de 5 Volts sur les cartes UNO.

Oscillateur à quartz
Un oscillateur à quartz est un élément électronique qui a la
particularité de posséder un quartz à l’intérieur qui vibre sous
l’effet piézoélectrique. Les propriétés électromécaniques du
4
quartz sont telles qu’on arrive à faire vibrer le quartz à une
fréquence très précise. Cet élément aide l’Arduino UNO à
calculer les données de temps. Sur le dessus du composant, on
peut lire 16.000H9H. Cela signifie que la fréquence est de
16,000,000 Hertz, soit 16 MHz.

Arduino Reset
Vous pouvez redémarrer un Arduino avec un “Reset”. Cela aura
pour effet de redémarrer votre programme depuis le début.
Vous pouvez redémarrer l’Arduino UNO de deux manières :
5,17
soit en utilisant le bouton “Reset” (17), soit en connectant un
bouton externe sur la broche de la carte Arduino
mentionnée “RESET” (5).

Broches (3.3, 5, GND, Vin)

 3.3V (6) – Broche d’alimentation de tension 3.3 Volts
6,7,8,9  5V (7) – Broche d’alimentation de tension 5 Volts
 La plupart des composants destinés à fonctionner avec Arduino
fonctionnent bien en 3.3 Volts ou 5 Volts.

10
  GND (8) (Ground / Masse) – Il y a plusieurs broches de ce type
présentes sur la carte Arduino, elles sont toutes communes et
peuvent être utilisées comme masse (potentiel 0 Volts) pour vos
circuits.
 Vin (9) – Cette broche permet d’alimenter l’Arduino depuis une
source de tension extérieure. Elle est reliée au circuit
d’alimentation principale de la carte Arduino.

Broches analogiques
L’Arduino UNO possède 5 broches d’entrées analogiques
numérotée de A0 jusqu’à A5. Ces broches permettent de lire
un signal analogique d’un capteur comme un capteur
10 d’humidité ou de température. La carte Arduino utilise un
convertisseur analogique/numérique (convertisseur CAN)
pour permettre la lecture du signal par le microcontrôleur. Un
signal sera converti sur 10 bits. La valeur pourra être lue sur
une échelle 1024 points.

Microcontrôleur principal
Chaque carte Arduino possède son propre
microcontrôleur (11). Vous pouvez le considérer comme le
cerveau de la carte Arduino. Le microcontrôleur sur l’Arduino
est légèrement différent d’une carte à l’autre. Les
microcontrôleurs sont généralement de la société ATMEL.
11 Vous devez savoir quel est le microcontrôleur de votre carte
avant de charger un nouveau programme depuis l’IDE Arduino.
Cette information est disponible directement sur le composant.
Pour plus de détails sur la construction et les fonctions du
microcontrôleur, vous pouvez vous référer à la fiche technique
(data sheet).

11
 Connecteur ICSP
Avant tout, le connecteur ICSP (In-Circuit Serial
Programming) est une connectique AVR comprenant les
broches MOSI, MISO, SCK, RESET, VCC et GND. Il s’agit
d’un connecteur de programmation. Ce connecteur permet entre
autre de programmer directement le microcontrôleur sur les
couches les plus basses (bootloader, code ASM…). C’est aussi
12
un port appelé port SPI (Serial Peripheral Interface), qui permet
de dialoguer avec d’autres composants SPI (écrans, capteurs,
etc…). On ne va pas se préoccuper de ce connecteur au début
des tutoriels.

Indicateur LED d’alimentation

Ce voyant doit s’allumer lorsque vous branchez votre Arduino
sur une source d’alimentation pour indiquer que votre carte est
13 correctement alimentée. Si cette lumière ne s’allume pas, il y a
un problème avec votre alimentation, et je ne parle pas de
nourriture ici.

LEDs TX et RX
Sur votre carte, vous trouverez deux indicateurs : TX
(émission) et RX (réception). Ils apparaissent à deux endroits
sur la carte Arduino UNO. Tout d’abord, sur les broches
numériques 0 et 1, pour indiquer les broches responsables de la
14
communication série. Deuxièmement, les LEDs TX et RX (13).
Le voyant TX clignote à une vitesse variable lors de l’envoi des
données série. La vitesse de clignotement dépend de la vitesse
de transmission utilisée par la carte. RX clignote pendant le
processus de réception. La vitesse de transmission s’exprime en
bauds, soit l’équivalent du bits/seconde si le signal est binaire.

Entrées/Sorties numériques
La carte Arduino UNO possède 14 broches d’Entrées / Sorties
numériques (15), dont 6 peuvent fournir une sortie PWM
(Pulse Width Modulation). Ces broches peuvent être
15
configurées pour fonctionner comme des broches numériques
d’entrée pour lire des valeurs logiques (0 ou 1) ou numériques.
Elles peuvent également être utilisées comme des broches de
sortie pour piloter différents modules comme des LEDs, des

12
 relais, etc. Les broches étiquetées “~” peuvent être utilisées
pour générer des PWM.

Broche AREF
AREF est l’acronyme anglais de “référence analogique”. Cette
16
broche est parfois utilisée pour définir une tension de
référence externe (entre 0 et 5 Volts) comme limite supérieure
pour les broches d’entrée analogiques.

1.2 Carte Arduino Mega

L’Arduino Mega 2560 est un autre produit populaire parmi les cartes Arduino. Parfaite pour
les applications Arduino un peu plus grandes, elle est constituée de tous les éléments
nécessaires pour permettre la construction d’objets évolués.

La carte Arduino Mega 2560 est constituée de 54 broches d’entrées/sorties, dont 15 sont
utilisables en PWM, de 16 broches d’entrées analogiques, de 4 ports série hardware, d’une
connectique USB, d’une connectique d’alimentation, d’un port ICSP et d’un bouton RESET.
Il est possible d’acheter la carte Arduino Mega 2560 entre 40 et 50 euros, sur le site officiel
Arduino (http://store.arduino.cc) ou sur d’autres sites de vente de produits high-tech.

Figure 4 : Description des entrées/sorties de la carte Arduino Mega 2560

Comme pour l’Arduino Uno, l’Arduino Mega 2560 peut être alimentée à travers le port USB
lorsqu’elle est branchée sur l’ordinateur, ou via la connectique d’alimentation avec le port
jack ou l’entrée d’alimentation. La source d’alimentation fournissant le meilleur voltage sera
sélectionnée comme source d’alimentation par la carte. Comme pour l’Arduino Uno, il est
conseillé d’utiliser une alimentation entre 7V et 12V de courant continu pour alimenter la
carte.

13
1.3 LCD

L’écran à cristaux liquides est constitué de

deux polariseurs dont les directions de
polarisation forment un angle de 90°,
disposés de chaque côté d’un sandwich,
formé de deux plaques de verre enserrant
des cristaux liquides. À chacune des
interfaces avec les cristaux liquides, une
couche de polymère, généralement
un polyimide, rainurée assure l’ancrage
des molécules au repos. Figure 5 : Ecran LCD

Les deux faces internes des plaques de verre comportent une matrice d’électrodes
transparentes pour le noir et blanc. L’épaisseur du dispositif et la nature des cristaux liquides
sont choisies de manière à obtenir la rotation désirée du plan de polarisation, en l’absence de
tension électrique (90° dans les écrans TN). Dans les écrans de grande dimension, on ajoute
des espaceurs, petites billes transparentes, dans l’espace rempli de cristaux liquides pour
maintenir la très faible épaisseur (20 µm) constante et précise.

L’application d’une différence de potentiel plus ou moins élevée entre les deux électrodes
d’un pixel entraîne un changement d’orientation des molécules, une variation du plan
de polarisation, et donc une variation de la transparence de l’ensemble du dispositif.

1.4 Servomoteur

Le servomoteur appartient au groupe des

moteurs électriques et se caractérise
essentiellement par sa très grande capacité de
régulation et par les possibilités de commande qui
en découlent. Dans ce contexte, il permet un
réglage exact de la position de l’angle, de
l’accélération et de la vitesse. Afin de pouvoir
offrir cette caractéristique, l’architecture
Figure 6 : Servomoteur
essentielle du servomoteur se compose, en plus
du moteur lui-même, d’un capteur de position du rotor compatible. Celui-ci, aussi appelé

14
capteur de position, capteur de rotation ou feedback moteur, est capable d’enregistrer avec
précision la position de l’arbre moteur à un moment précis.
L’électronique de régulation – appelée servo-régulateur et généralement installée à l’extérieur
du servomoteur – se charge ensuite du traitement des informations et des éventuels ajustements
qui en résultent. Celui-ci compare les valeurs prévues en temps réel et apporte des corrections
le cas échéant, créant ainsi un circuit de régulation. Ce processus s’effectue en continu et a pour
but de diminuer au maximum ou plutôt de compenser les différences potentielles entre la valeur
théorique et la valeur réelle. Le rotor conserve toutefois sa position définie ; les modifications
de position ne se produisent que lorsqu’une charge, une pression ou d’autres conditions sont
appliquées.
Le circuit de régulation est généralement intégré à un servomoteur comme système de
régulation. Le fonctionnement de ce dernier peut être régulé soit par couple, soit par vitesse ou
encore par position. Une intrication de ces variantes est possible grâce à des systèmes de
régulation complexes par cascadage.

1.5 Moteur pas à pas : Stepper

Le moteur pas à pas constitue un convertisseur électromécanique destiné à transformer le signal

électrique (impulsion) en déplacement (angulaire ou linéaire) mécanique.
Entre le moteur et son alimentation, sont intercalés trois éléments essentiels :
 Une unité de calcul, qui élabore les impulsions de commande.
 Un modulateur PWM, qui génère les commandes des contacteurs électroniques de
commutation.
 Une électronique de commutation (puissance), qui, à partir d’une alimentation, fourni
l’énergie vers les enroulements approprié de moteur.

Figure 7 : Bipolaire Stepper

15
1.5.1 Principe de commande d’un moteur pas à pas
A chaque impulsion du signal de commande correspond au niveau du rotor un déplacement
angulaire défini appelé « pas » ou « incrément mécanique ». La fréquence de rotation est en
fonction de la fréquence des impulsions.

Figure 8 : Principe de moteur pas à pas

1.6 L293D

Le dispositif L293 est un pilote monolithique intégré

haute tension et courant élevé à chaque canaux conçu
pour accepter les niveaux logiques DTL ou TTL standard
et piloter des charges inductives (telles que des
solénoïdes de relais, DC et moteurs pas à pas) et des
transistors de puissance à découpage. Pour simplifier
l’utilisation comme deux ponts, chaque paire de canaux
est équipée d’une entrée d’activation. Une entrée
d’alimentation séparée est fournie pour la logique, Figure 9 : L293D

permettant un fonctionnement à une tension inférieure et des diodes de serrage internes incluses.
Cet appareil convient pour une utilisation dans des applications de commutation à des
fréquences allant jusqu’à 5 kHz.
Le L293D est assemblé dans un emballage en plastique de 16 conducteurs qui a 4 broches
centrales reliées entre elles et utilisées pour la dissipation thermique. Le L293D est assemblé
dans un montage en surface à 20 conducteurs qui a 8 broches centrales connectées ensemble en
utilisées pour la dissipation thermique.

16
 Figure 10 : Connexions des pins

Pour chaque canal, Vs=24V, Vss=5V, Tamb=25°C

Figure 11 : Caractéristiques électriques de L293D

1.7 Capteurs
1.7.1 LDR
Une photorésistance est un composant dont la
valeur en ohms dépend de la lumière à laquelle il
est exposé. On la désigne aussi par LDR (Light
Dependent Resistor = résistance dépendant de la
lumière).
Figure 12 : LDR

17
La principale utilisation de la photorésistance est la mesure de l'intensité lumineuse (appareil
photo, systèmes de détection, de comptage et d'alarme...). Elle est fortement concurrencée par
la photodiode dont le temps de réponse est beaucoup plus court. Les matériaux utilisés sont
généralement du sulfure ou du séléniure de cadmium qui se comportent comme des semi-
conducteurs.

Un cristal de semi-conducteur à température basse contient peu d'électrons libres. La

conductivité du cristal est très faible, proche de celle d'un isolant. Lorsque la température du
cristal augmente de plus en plus d'électrons qui étaient immobilisés dans les liaisons covalentes
s'échappent et peuvent participer à la conduction.

A température constante si le même cristal semi-conducteur est soumis à une radiation

lumineuse, l'énergie apportée par les photons peut suffire à libérer certains électrons utilisés
dans les liaisons covalentes entre atomes du cristal. Plus le flux lumineux sera intense, plus le
nombre d'électrons disponibles pour assurer la conduction sera grand, ainsi la résistance de la
LDR est inversement proportionnelle à la lumière reçue.

La sensibilité dépend de la fréquence de la radiation lumineuse : par exemple, le sulfure de

cadmium a un maximum de sensibilité dans le spectre de la lumière visible aux environs de
650nm, dans le rouge du spectre lumineux, d'autres matériaux comme le sulfure de plomb sont
plutôt utilisés dans l'infrarouge (>670nm).

1.7.2 LM35
Le capteur de température est un dispositif qui permet de transformer une grandeur physique
(Température) en une grandeur électrique (tension ou courant).Comme le capteur de lumière il
existe deux type du capteur (actif et passif), dans notre cas nous allons utiliser un capteur du
type actif (Circuit intégré LM35).
Le capteur LM35 est un capteur de température où la tension de sortie est linéairement
proportionnelle à la température en Celsius centigrade. Ce capteur ne nécessite pas de calibrage
externe pour fournir une précision °C sur une gamme de température de -55°C à +150°C. Son
coefficient est de 10mV/°C et dans notre cas le capteur est alimenté par 0-5V, on ne peut
mesurer par conséquent que des températures positives.
Le capteur LM35 est commercialisé dans boiter 3 broches classiques, comme illustré dans la
figure.

18
 Figure 13 : LM35

1.7.3 MPX4115
Un capteur de pression convertit la pression en signal électrique
analogique. Bien qu'il existe plusieurs types différents de capteurs de
puissance, nous avons utilisé le MPX4115 un capteur qui fonctionne à
5V et à une portée de 15 à 115 kPa. Le gros avantage de ce capteur c’est
qu’il renvoi une tension proportionnel à la pression mesuré, il est donc
très facile à mettre en œuvre. La mesure de pression du transducteur
produit une déviation de la membrane qui introduit la contrainte aux
jauges. La contrainte produira un changement de résistance électrique
Figure 14 : MPX4115
proportionnel à la pression.

 Branchement

Figure 16 : Branches du MPX4115 Figure 15 : Montage isis

19
  Calcul de pression

Figure 17 : la sortie en fonction de la pression absolue

1.7.4 DHT11
Le capteur DHT11 se compose d'un élément de détection
d'humidité capacitif et d'une thermistance pour détecter la
température. Le condensateur de détection d'humidité a deux
électrodes avec un substrat de rétention d'humidité comme
diélectrique entre elles. Le changement de la valeur de
capacité se produit avec le changement des niveaux
Figure 18 : DHT11
d'humidité. L'IC mesure, traite ces valeurs de résistance
modifiées et les change sous forme numérique.

Pour mesurer la température, ce capteur utilise une thermistance à coefficient de

température négatif, ce qui entraîne une diminution de sa valeur de résistance avec
l'augmentation de la température. Pour obtenir une valeur de résistance plus grande même pour
le plus petit changement de température, ce capteur est généralement composé de céramiques
ou de polymères semi-conducteurs.

20
 La plage de température du DHT11 est de 0 à 50 degrés Celsius avec une précision de 2
degrés. La plage d'humidité de ce capteur est de 20 à 80% avec une précision de 5%. La
fréquence d'échantillonnage de ce capteur est de 1 Hz .i.e. il donne une lecture pour chaque
seconde. DHT11 est de petite taille avec une tension de fonctionnement de 3 à 5 volts. Le
courant maximal utilisé lors de la mesure est de 2,5 mA.

21
2 Logiciels
2.1 Arduino
L'environnement de développement intégré
Arduino est une application multiplateforme
qui est écrite dans des fonctions de C et C ++. Il
est utilisé pour écrire et télécharger des
programmes sur des cartes compatibles
Arduino, mais aussi, avec l'aide de cœurs tiers,
d'autres cartes de développement de
fournisseurs.

2.2 Proteus
La CAO électronique Proteusest une suite
logicielle, éditée par la société Labcenter Electronics
et revendue en France exclusivement par Multipower.
Proteus est actuellement (2020) la seule CAO
électronique qui permet la conception d'un système
électronique complet et de le simuler, y compris avec
le code des microcontrôleurs. Pour ce faire, elle inclut
un éditeur de schéma (ISIS), un outil de placement-
routage (ARES), un simulateur analogique-numérique, un environnement de développement
intégré pour microcontrôleurs, un module de programmation par algorigrammes ainsi qu'un
éditeur d'interface pour smartphone afin de piloter à distance des cartes Arduino ou Raspberry.

2.3 LABVIEW
LABVIEW (Laboratory Virtual Instrument Engineering
Workbench) est un langage de programmation dédié au contrôle
d’instruments et l’analyse de données. Contrairement à la nature
séquentielle des langages textuels, LABVIEW est basé sur un
environnement de programmation graphique utilisant la notion flot de
données pour ordonnancer les opérations. En effet, il existe deux formes

22
de programmation graphiques. Une programmation dite flot de contrôle et une autre dit flot de
données.

2.3.1 Programmation flot de contrôle

Ils ont longtemps été utilisés pour décrire les algorithmes, ces représentations décrivent les
programmes comme étant de nœud de calcul connecté par des arcs spécifiant quel calcul doit
être effectué ensuite.

2.3.2 Programmation flot de données

C’est une fonction analogue à la propagation du signal à travers un circuit électrique. Le
diagramme flot de données est un graphe acyclique qui peut être composé de 3 éléments
suivants :

 Des terminaux : qui sont les liens avec l’extérieur qui représente la production où la
consommation de données.
 Des Nœuds : qui sont les traitements à effectuer et qui sont représenté par une figure
géométrique pouvant contenir une image illustrant leur fonctionnalité.
 Les arcs orientés : qui relient les nœuds et les terminaux et permettent d’indiquer le
passage de données d’un nœud vers un autre.

23
 Chapitre 3
Conception et simulation
1 Description du circuit

Figure 19 : circuit électrique du système

1.1 LDR
L’entrée des 4 photoresistors sont branchées à une alimentation de +5v et les sorties
independentes sont reliées à des résistances pulldown et le potentiel entre la résistance et LDR
au pin analogique de la carte arduino (A0, A1, A2, A3) car les données recueillies sont de type
analogique.

24
1.2 LCD
L’écran LCD 20×4 présente 16 broches pour permettre la gestion de l’affichage et du
contraste :

 VSS Relier à la masse de l’écran

 VDD Broche d’alimentation connectée à la broche 5V de l’Arduino.
 RW conectée à la masse.
 RS conectée au pin 8 de la carte Arduino.
 E enable connectée au pin 9 de la carte Arduino.
 D4 4 bits de poids faible de la communication I2C connectée au pin 10 de la carte
Arduino.
 D5 4 bits de poids faible de la communication I2C connectée au pin 11 de la carte
Arduino.
 D6 4 bits de poids faible de la communication I2C connectée au pin 12 de la carte
Arduino.
 D7 4 bits de poids faible de la communication I2C connectée au pin 13 de la carte
Arduino.

1.3 Servomoteur
Le câblage est relativement simple : un fil de la broche supérieur du servomoteur sur la
broche 5V de la carte Arduino, la broche inferieur sur la broche GND et un fil de la broche au
milieu du servomoteur vers Le pin 5 pour le premier servomoteur, et le pin 6 pour le deuxième
servomoteur, de la carte Arduino Uno.

1.4 LM35
Trois branche, une brancher avec une alimentation de 5v l’autre avec la masse et la dernière
avec l’entrée analogique (A4) de la carte Arduino uno.

1.5 MPX4115
Branche numéro 1 est branché avec l’entrée analogique (A5) de la carte Arduino uno, la
deuxième branche avec la masse et la troisième avec une alimentation de 5v.

2 Programmation Arduino
Le logiciel de programmation de la carte Arduino code est basé sur le langage C. Une fois
le programme est tapé, il sera mémorisé dans la carte.
Afin de programmer le servomoteur à suivre les valeurs délivrées par les capteurs LDR. ,
nous utilisons une suite d’instructions élémentaires sous forme textuelle, ligne par ligne. Puis,
la carte lit et effectue ces instructions dans l’ordre défini par les lignes de code.

25
2.1 Circuit 1 : servomoteur commandé par une LDR
Dans un premier lieu, nous commençons par la programmation de la carte Arduino pour
commander un seul servomoteur à suivre un seul capteur LDR. Par conséquent, nous importons
les bibliothèques LiquidCrystal et Servo qui vont nous permettre d’effectuer des fonctions
complexes sans la nécessité de les développer à nouveau.
En deuxième lieu, nous définissons les variables suivantes :
 Une variable myservo de type Servo afin de pouvoir manipuler le servomoteur.
 Un objet pour pouvoir commander ensuite l’écran à l’aide de la commande
LiquidCrystal qui possède comme paramètres les broches de l’arduino liés aux
broches de LCD.
 Les variables analogpin et val qui correspondent successivement à l’entrée analogique
A0 lié au capteur et une variable val qui sera exploitée pour une telle fonction
expliquée par la suite.
Par la suite, nous configurons les entrées et les sorties dans la fonction void setup().
Premièrement, on attache la broche lié au servomoteur en utilisant la méthode .attach(). Cette
méthode met l’angle du servomoteur à 90° par défaut. En second, nous initialisons l’interface
avec le LCD à travers la fonction begin() afin de spécifier les caractéristiques de l’écran, à
savoir le nombre de lignes et de caractères par ligne.
En dernier lieu, nous programmons les interactions ainsi que les comportements au sein de
la fonction void loop(). Nous débutons par la lecture de la broche analogique, cette valeur lu
sera stockée dans la variable val. Ensuite, nous modifions la plage de variation de val qui est de
0 à 1023 à une plage de 0 à 180° imposée par le servomoteur. Dans le but de faire bouger ce
dernier en fonction de LDR, nous exploitons la méthode. write() qui prend en paramètre la
variable val. Afin d’afficher la valeur de l’angle dans LCD, nous utilisons la fonction
#include <Servo.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(2,3,4,5,6,7); Servo myservo;
int analogpin=0;
float val;
void setup() {
myservo.attach(9); lcd.begin(16,2);
pinMode(analogpin,INPUT);}
void loop() {
val=analogRead(analogpin);
val=map(val1,0,1023,0,180);
myservo.write(val); delay(15);
lcd.setCursor(3,0); lcd.print("Servomoteur");
lcd.setCursor(2,1); lcd.print("angle: ");
lcd.setCursor(8,1); lcd.print(val);}

Figure 20 : code du circuit1

26
Setcursor() pour placer le curseur selon les colonnes et les lignes ainsi que la fonction .print()
pour imprimer du texte sur l’écran à partir de la position du curseur.

2.2 Circuit 2 : deux servomoteurs commandés par un LDR

Cette fois ci, nous programmons la carte Arduino à commander un servomoteur selon deux
capteurs LDR. Avec le même principe, nous ajoutons au code précédent la déclaration de la
broche liée au deuxième capteur ainsi que la lecture de celle-ci. Et dans la fonction loop() nous
définissons deux boucles qui s’exécutent si la condition en paramètre est vérifiée.

#include <Servo.h> void loop() { myservo1.write(0);

#include <LiquidCrystal.h>
valldr1=analogRead(pinldr1);
Servo myservo1; valldr2=analogRead(pinldr2);
const int rs = 8, en = 9, d4 = 10, d5 = 11,
while ((valldr1-valldr2)>10 && pos1<180) {
d6 = 12, d7 = 13;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7); pos1=pos1+1; myservo1.write(pos1);
const int pinldr1=A0;
valldr1=analogRead(pinldr1);
const int pinldr2=A1;
int pos1=0; int valldr1=0; valldr2=analogRead(pinldr2); delay(500);}
int valldr2=0;
while ((valldr1-valldr2)<-10 && pos1>0)
void setup() {
myservo1.attach(5); {pos1=pos1-1; myservo1.write(pos1);
myservo1.write(0);
valldr1=analogRead(pinldr1);
valldr1=analogRead(pinldr1);
valldr2=analogRead(pinldr2);} valldr2=analogRead(pinldr2); delay(500);}}

Figure 21 : codes du circuit2

2.3 Circuit 3 : deux servomoteurs commandés par 4 LDR

Nous effectuons la programmation des deux servomoteurs dans le but de le faire tourner
d’un angle en fonction de la luminosité des 4 capteurs.
Dans ce sens, nous configurons d’un côté les entrées analogiques pinldr1, pinldr2, pinldr3
et pinldr4 qui correspondent successivement à LDR1, LDR2, LDR3 et LDR4 et de l’autre côté
les sorties qui sont liées aux deux servomoteurs en utilisant la méthode .attach( ) qui prend en
paramètre le numéro de la broche.
Nous programmons les interactions et les comportement au sein de la fonction void loop( ).
Nous commençons par la lecture des 4 broches analogiques. Ces valeurs seront stockées dans
les variables valldr1, valldr2, valldr3 et valldr4. A l’aide de ses dernières variables citées, nous
effectuons deux comparaisons : une entre LDR1 et LDR2 et une autre entre LDR3 et LDR4

27
dans le but de commander les deux moteurs en utilisant la méthode .write( ) qui prend en
paramètre l’angle de rotation choisie.

#include <Servo.h>
#include <LiquidCrystal.h>
Servo myservo1;
Servo myservo2;
const int rs = 12, en = 11, d4 = 5, d5 = 4,
d6 = 3, d7 = 2;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
const int pinldr1=A0;
const int pinldr2=A1;
const int pinldr3=A2;
const int pinldr4=A4;
int valldr1=0;
int valldr2=0;
int valldr3=0;
int valldr4=0;
void setup() {
myservo1.attach(9);
myservo2.attach(10);
lcd.begin(16, 2);
}

La programmation de LCD reste le même que le précédent, sauf que cette fois-ci, nous
affichons aussi les valeurs de températures et de pressions.
void loop() {
myservo1.write(90); myservo2.write(90);
delay(1000); lcd.clear();
valldr1=analogRead(pinldr1);
valldr2=analogRead(pinldr2);
valldr3=analogRead(pinldr3);
valldr4=analogRead(pinldr4);
if(valldr1<valldr2)
{myservo1.write(0); lcd.setCursor(0, 1);
lcd.print("0"); lcd.setCursor(4,1);
delay(1000);}
else if (valldr1>valldr2)
{myservo1.write(180); lcd.setCursor(0, 1);
lcd.print("180"); lcd.setCursor(4,1);
delay(1000);}
else {myservo1.write(90); lcd.setCursor(0, 1);
lcd.print("90"); lcd.setCursor(4,1);
delay(1000);}

28
2.4 Circuit 4 : deux moteurs pas à pas commandés par 4 LDR
Afin de programmer le moteur pas à pas à suivre les valeurs délivrées les capteurs LDR,
ainsi que d’afficher les mesures d’ensoleillement, de la température dans LCD. La
programmation est similaire à celle du circuit 4 sauf que dans celle-ci nous importons la
bibliothèque correspondante au stepper.

const int stp1=200;

const int stp2=200;
const int stp1=200;
const int stp2=200;
Stepper steper1(stp1,8,9,10,11);
Stepper steper2(stp2,2,3,6,5);
const int rs = 27, en = 26, d4 = 25, d5 = 24, d6 = 23, d7 = 22;
LiquidCrystal lcd(rs, en, d4, d5, d6, d7);
const int pinldr1=A0;
const int pinldr2=A1;
const int pinldr3=A2;
const int pinldr4=A3;
const int pintemp=A5;
const int pinpress=A6;
int valldr1=0;
int valldr2=0;
int valldr3=0;
int valldr4=0;
int valtemp=0;
int valpress=0;
float conv=0;

if(valldr3<valldr4)
{myservo2.write(0); lcd.setCursor(4, 1);
lcd.print("0"); lcd.setCursor(5,1);
delay(1000);}
else if (valldr3>valldr4)
{myservo2.write(180); lcd.setCursor(4, 1);
lcd.print("180"); lcd.setCursor(5,1);
delay(1000);}
else
{myservo2.write(90); lcd.setCursor(4, 1);
lcd.print("90"); lcd.setCursor(5,1);
delay(1000);}
valldr1=analogRead(pinldr1);
valldr3=analogRead(pinldr3);
lcd.setCursor(0, 0);
lcd.print(valldr1); lcd.setCursor(6,0);
lcd.print(valldr3); lcd.setCursor(12,0);
delay(5000);}Figure 22 : codes du circuit3

29
 Nous débutons par la lecture des broches analogiques. Les valeurs lues seront stockées dans
les variables valldr1, valldr2, valldr3 et valldr4.
void setup() {
// put your setup code here, to run once:
steper1.setSpeed(20);
steper2.setSpeed(20);
lcd.begin(20,4);
Serial.begin(9600);
Serial1.begin(9600);

valldr1=analogRead(pinldr1);
valldr2=analogRead(pinldr2);
valldr3=analogRead(pinldr3);
valldr4=analogRead(pinldr4);
}

Nous configurons les quatre cas possibles à l’aide de quatre boucles while(). Dans celles-
ci, nous commandons les moteurs pas à pas selon les conditions mises en paramètres.

while (valldr3-valldr4<-10)
{
steper2.step(-1);
delay(500);
valldr3=analogRead(pinldr3);
valldr4=analogRead(pinldr4);
}
lcd.clear();
lcd.setCursor(0, 0);
valldr3=analogRead(pinldr3);
lcd.print("ensoleillement:");
lcd.print(valldr3);
lcd.setCursor(0,1);
lcd.print("temperature:");
valtemp=analogRead(pintemp);
conv=map(valtemp,0,1023,0,1000)/10;
3 SIMULATION
lcd.print(conv);
lcd.print("C");
Après avoir réalisé le schéma sur Proteus, et programmé notre Arduino uno, nous sommes
passéslcd.setCursor(0,2);
à la simulation de notre circuit réalisé. Afin de déduire le lien entre la quantité de lumière
captéelcd.print("pression:");
par les photorésistances LDR et la rotation des servomoteur utilisés , nous avons étudié
valpress=analogRead(pinpress);
plusieurs cas .
conv=((float)valpress/(float)1023+0.095)/0.009;
lcd.print(conv);
lcd.print("kPa");

30
3.1 Circuit 1 : Servomoteur commandé par une LDR
Dans un premier Lieu, nous avons commencé par réaliser un simple circuit contenant une
photorésistance et un seul Servomoteur . Nous avons ainsi traité plusieurs cas, à chaque fois
nous augmentons la luminosité et nous notons la valeur de l’angle du servomoteur affiché sur
notre LCD.

D’après les différents cas traités, nous avons pu vérifier que plus nous augmentons la
luminosité c’est à dire plus la quantité de lumière captée par la photorésistance LDR est grande
plus l’angle du servomoteur augmente.

3.2 Circuit 2 : Servomoteur Commandé par deux LDR

Dans un deuxième lieu , nous sommes passés à la réalisation du même circuit sauf que cette
fois le Servomoteur est commandé par deux photorésistances LDR . Afin de déduire le lien
entre la quantité de lumière captée par les deux photorésistances LDR et la rotation des
servomoteur utilisé , nous avons étudié les deux cas suivants :

31
  1 er cas : LDR1<LDR2

 Le moteur a commencé à tourner vers la droite .

 2 eme cas : LDR2<LDR1

 Le Servomoteur a changé son sens de rotaton , il a commencé à tourner vers inverse

vers la gauche .

3.3 Circuit 3 : Deux Servomoteurs et 4 photorésistances LDR

 1er Cas : LDR2>LDR1

Dans un premier essai nous avons appliqué pour LDR2 une valeur de luminosité supérieure
à celle appliquée au niveau de LDR1 , nous avons ainsi observé que le Servomoteur a
commencer à tourner vers la droite .

32
 Remarque : Plus nous augmentons la valeur du LDR2 plus l’angle avec laquelle le
Servomoteur tourne augmente.
 2ème cas : LDR1>LDR2

Cette fois-ci nous avons inversé les choses, c’est-à-dire la plus grande valeur de luminosité
était au niveau du LDR1. Par conséquent le Servomoteur à commencer à tourner au sens inverse
(vers la gauche).

Nous avons vérifié la même chose pour le deuxième servomoteur

 3ème cas : LDR3<LDR4

Nous avons appliqué dans un premier temps une valeur de luminosité au niveau du LDR4
supérieure à celle appliquée au niveau de LDR3, nous avons ainsi remarqué que le Servomoteur
a bien commencer à tourner vers la droite.

33
  4éme Cas : LDR3 > LDR4
Dans ce cas, le Servomoteur a inversé son sens de rotation, Il a commencé à tourner
vers la gauche.

Conclusion : D’après les différents cas traités, nous avons pu vérifier que la valeur de
l’angle et le sens de rotation de nos deux servomoteurs sont effectivement dépendants et
commandés par les valeurs des photorésistances correspondantes.
Enfin, nous avons utilisé au niveau de notre circuit deux autres capteurs : un capteur de
pression et un capteur de température, de telles informations sont très intéressantes et peuvent

34
être utilisés dans plusieurs études et contextes. Les deux valeurs des deux capteurs sont
affichées sur LCD de notre circuit accompagnées de la valeur de l’ensoleillement.

3.4 Circuit 4 : 2 Moteur pas à pas Stepper et 4 LDR

Choisir entre servomoteur ou moteur pas-à-pas peut être délicat. Il y a évidemment plusieurs
considérations à prendre en compte. Par exemple : le coût, le couple, la vitesse, l’accélération
et la façon de le piloter. Utiliser un moteur inadapté peut provoquer des problèmes de
performances.
Les moteurs pas à pas STEPPER sont très facile à configurer, disponibles très largement
pour un coût modeste. Ils ne nécessitent qu’un système de pilotage très simple. Nous avons
donc ainsi décidé d’essayer de réaliser notre projet avec cette fois-ci le moteur pas à pas Stepper
et la carte Arduino Méga et par la suite choisir celui qui nous correspond le plus.

35
 Lors de la simulation nous avons bien obtenu les mêmes résultats, Il faut noter que pour un
moteur pas à pas, le couple diminue de manière importante lorsque la vitesse augmente. En
effet, lorsque le couple diminue, le moteur peut alors « sauter » un pas, c’est-à-dire que le
moteur ne suivra pas l’ordre du contrôleur de moteur . Vu la faible vitesse de rotation du
panneau , la puissance est ridiculement faible . Par conséquent Un moteur pas à pas devrait bien
convenir.

4 Cahier de charge et représentation en LABVIEW

Le suiveur solaire fonctionnera selon les capteurs. Il se déplace vers le capteur qui a le plus
de luminosité.
Etape 1 : Lecture des deux capteurs
Etape 2 : Comparaison :
 Si valeur capteur 1 >valeur capteur 2
Alors moteur tourne dans le sens positif
Délai 500ms
Tant que valeur capteur 1 > valeur capteur 2
Faire tourner le moteur dans le sens positif
 Sinon Faire tourner le moteur dans le sens inverse
Tant que valeur capteur 1 < valeur capteur 2
Faire tourner le moteur dans le sens inverse
Délai 500ms

36
4.1 Algorithme LABVIEW
Comme pour tout langage de programmation, il est nécessaire d’avoir une certaine
méthode lorsque nous développons un programme avec LabVIEW. Ainsi, nous utilisons
une structure de condition qui permet de sélectionner un élément parmi une liste au
moyen d’une structure de contrôle de type « Case ». Cette structure case est une
structure de contrôle de programmation permettant d’effectuer plusieurs choix.

Figure 23 : Algorithme en LABVIEW

37
 Conclusion générale
Dans ce projet, nous nous sommes concentrés sur la conception et la réalisation d'un
système de poursuite de soleil à l'aide des composants électroniques programmables
(Arduino…) et des composants électroniques (Servomoteur, Stepper, LCD...), des capteurs
(LDR, MPX4115,DSH11...).
Le système de suivi solaire est utilisé pour diriger le panneau solaire ou plus
particulièrement le capteur vers le soleil en continu, ce qui est essentiel pour les grands systèmes
de mise au point et améliore considérablement les performances des capteurs. Le but de ce
projet réside au niveau de la mise en œuvre d'une solution technique permettant de transformer
un panneau photovoltaïque fixe en un mobile en utilisant un suiveur de soleil afin d'améliorer
son rendement.
Notre solution consiste l'utilisation de quatre photorésistances (LDR) placées selon une
géométrie bien précise sur le support des panneaux photovoltaïques. Les signaux issus de ces
quatre capteurs sont traités par l'Arduino qui commande les motoréducteurs à travers un circuit
de commande.
Ce projet nous a apporté de nouvelles connaissances dans le domaine des énergies
renouvelables et en particulier l’énergie solaire qui est en plein essor et nous a permis de mettre
en pratique nos connaissances acquise en Electronique .
Nous saisissons cette occasion pour exprimer nos sincères remerciements à Mr. EL
RHARRASS pour son accompagnement, son dévouement et son soutien.

38