Rapport Geiger Jovet .pdf



Nom original: Rapport_Geiger_Jovet.pdfAuteur: Victor

Ce document au format PDF 1.6 a été généré par Acrobat PDFMaker 10.1 pour Word / Adobe PDF Library 10.0, et a été envoyé sur fichier-pdf.fr le 07/11/2014 à 16:19, depuis l'adresse IP 193.48.x.x. La présente page de téléchargement du fichier a été vue 591 fois.
Taille du document: 3.3 Mo (19 pages).
Confidentialité: fichier public


Aperçu du document


0

Sommaire

• Introduction……………………………………………………….…2
• Cahier des charges………………………………………………….3

• Partie Analogique ………………………………………………….4~10
 Sonde Ensoleillement…………………………………5
 Anémomètre – Ventilateur………………………….9
• Partie Informatique……………………………………………….11~16
 Structures de Données……………………………….11
 Découpage……………………………………………….12
 Déroulement du programme………………………..12
 Initialisations…………………………………………..14
 Présentation des résultats…………………………..15
• Conclusion………………………………………………………………17








Annexe 1 : Zoom Physique
Annexe 2 : Gestion de Projet
Annexe 3 : Schématic et Board
Annexe 4 : Diagramme de Bode
Annexe 5 : Documentation TL072
Annexe 6 : Documentation ICL232

1

Introduction

This project is about creating a weather plant which could inform its user of the wind
speed and of the sunshine.
We had to manage two sensors, an anemometer as well as a photovoltaic cell. In order to get
reliable information from them, we had to meet some requirements, like creating a function
to calibrate the anemometer automatically each time it’s started. What’s more, we made a
board to amplify and filter the electrical signal coming from the photovoltaic cell.
In everyday life, a weather station is used to collect information on the environment, for
individuals as well as for companies. It might be used as simple information to be aware of
the weather while companies will use it as a source of information to manage their
equipment (Security on a machine if the wind speed is too high, for instance).
This weather plant is autonomous, which makes it an adequate tool to regulate a system
without human intervention/ constant oversight.

First of all, we are going to present the specifications of our project, and which upgrades we
included. Then we will introduce you the analog part of the project, in order to show how we
managed the two sensors.
This will be followed by the I.T part presentation, where we will justify how we programmed
the functions and finally, we will make our conclusion on this project.

2

Cahier des charges :

Nous devons mesurer et afficher sur le PC la vitesse du vent en m/s et l'ensoleillement en
W/m².
Pour l'ensoleillement, nous devons utiliser une sonde photovoltaïque qui délivre une tension
proportionnelle à la luminosité (69,4 mV pour 1000W/m²). Cette mesure doit s’effectuer
pour un ensoleillement compris entre 0 et 2000 W/m². Le signal délivré par la sonde devra
également être filtré contre les parasites supérieurs à 5Hz.

Pour la vitesse du vent, le ventilateur de la maquette simulera le vent. Il faut au préalable
étalonner l'anémomètre. Cette phase d’étalonnage devra s'effectuer lors de l’appui sur un
bouton poussoir, le ventilateur générera des vents connus et pour chacun de ces vents, il
faudra mesurer et enregistrer la fréquence donnée par l'anémomètre. Une fois celui-ci
étalonné, pour mesurer des vents quelconques, il suffira de mesurer la fréquence renvoyée
par l'anémomètre et extrapoler linéairement entre 2 points d’étalonnage les plus proches. Si
les mesures paraissent fausses ou s’il y a eu un problème pendant la phase d'étalonnage
(intervention humaine par exemple), un nouvel étalonnage de l'anémomètre devra être
effectué par un nouvel appui sur un bouton poussoir.
Amélioration :
L’alimentation du système de traitement du signal délivré par la sonde photovoltaïque devra
être exclusivement alimentée par la mono-tension disponible sur l’Arduino.

3

Sché ma fonctionnel

Ecran
Affichage deSchéma
la vitesse
du vent et de la luminosité
fonctionnel

CAN

Signal de
l’ensoleillement
amplifié et filtré

Alimentation en
mono-tension

Interruption
sur tous fronts

PWM

ARDUINO
Partie informatique

Signal TTL
Signal TTL
Transistor
MOFSET

Alimentation Symétrique
(ICL232)

Carte Electronique
Partie Analogique

Amplification-Filtrage
(TL072)

Tension continue proportionnelle
à l’ensoleillement
Anémomètre

Alimentation
12V
4

Partie Analogique
Utilisation de la sonde d'ensoleillement
Comme indiqué dans le cahier des charges, la sonde photovoltaïque délivre un signal
proportionnel à l'ensoleillement : 0V pour une puissance de 0W/ m², et 138,8 mV pour 2000W/m².
On se rend alors compte que l'intervalle de variation de la tension délivrée par cette sonde est trop
faible pour être traité correctement et surtout précisément par l'Arduino. En effet, nous comptons
travailler avec le convertisseur analogique-numérique (CAN) de l'Arduino pour traiter le signal
sortant de la sonde photovoltaïque, ce signal étant de type analogique. Or, il est intéressant pour
nous qu'il varie entre 0 et 5V, afin d’exploiter la plage la plus grande disponible, car au-delà de ces
tensions, il y a un risque d’abîmer l'Arduino. Nous devons donc amplifier le signal.
Le cahier des charges nous impose également de filtrer les parasites supérieurs à 5Hz, pour ne pas
subir la luminosité artificielle. Nous allons donc créer un filtre passe-bas actif.
Un filtre passe-bas actif du premier ordre suffit. En effet, nous voulons essentiellement éliminer la
composante de 50 Hz de la lumière artificielle, et celle-ci se trouve une décade en dessous de notre
fréquence de coupure. Vu la faible tension délivrée par la sonde, une atténuation de 20 décibels
suffit.
Quel doit être l'amplification du signal envoyé par la sonde photovoltaïque ? Pour un plein soleil,
donc pour V sonde = 168,8 mV, on veut avoir 5V en entrée de l'Arduino. L'amplification A v est alors de :

𝐴𝑣 =

𝑈𝑠
5
=
𝑈𝑒 0.1688

𝐴𝑣 = 36

Nous devons donc amplifier par 36 le signal envoyé par la sonde photovoltaïque pour avoir une plage
de variation entre 0 et 5V.

L'Arduino faisant partie du domaine de l'informatique et de l'électronique embarquée, il est
intéressant d'optimiser les ressources qui sont à notre disposition. Pour cela, nous allons donc utiliser
l'alimentation +5V/0V disponible sur la maquette Arduino pour alimenter le filtre passe-bas et non
faire appel à une alimentation externe.

5

Étant habitués à travailler avec le TL072 pour créer des filtres-amplificateurs, nous décidons d'utiliser
ce composant pour notre application. Cet AOP a besoin d'être alimenté symétriquement. Un
problème se pose alors : comment, à partir de l'alimentation +5/0V de l'Arduino, peut-on créer une
alimentation symétrique +5V/-5V au minimum en prenant en compte les tensions de déchet du
TL072 ?
Nous avons alors fait appel à un nouveau composant : l’ICL 232. Ce composant est conçu pour être
un émetteur-récepteur de ligne pour la liaison RS232, mais on peut aussi voir que lorsqu'il est monté
d'une certaine manière, ce composant transforme sa tension d'alimentation +5/0V en tension
symétrique +10V/-10V que l'on peut récupérer sur ses pattes 2 et 6, la patte 2 fournissant le +10V, la
patte 6 fournissant le -10V.
La documentation technique nous fournit le montage qui permet de réaliser cette alimentation
symétrique (cf Annexe 6).
Nous réalisons donc ce montage et mesurons au voltmètre les tensions de sorties : Nous avons bien
10 volts sur la patte 2 (9,8 volts précisément) et -10 volts sur la patte 6 (-9,6 volts précisément).
Nous alimentons par la suite le TL072 grâce à ces alimentations, et nous observons une chute de
tensions d'environ 4 Volts sur chaque patte d'alimentation du TL072. La patte V+ est donc alimentée
par une tension de 6 Volts et la patte V- est alimentée par une tension de -6,2 Volts. En prenant en
compte la tension de déchet du TL072 qui n'excède pas 1 Volt, nous sommes alors sûr que le signal
de sorti de l'AOP pourra varier entre 0 et 5V, comme nous l'avions défini plus haut. Il reste alors à
dimensionner les composants.
Voici le montage d'un filtre passe-bas à base de TL072 (cf Annexe 5).

Il faut déterminer la fonction de transfert de ce filtre.
La résistance R 2 est en parallèle avec le condensateur C. Cet ensemble forme un rebouclage de la
sortie sur l'entrée e- : l'AOP fonctionne alors en linéaire, et on peut écrire que e+ = e-.
Soit Z 2 l'impédance équivalente du bloc formé par la résistance R 2 et le condensateur C.
1
1
1
=
+
Z2 𝑅2 𝑍𝐶

1
1
=
+ 𝑗𝐶ω
Z2 𝑅2

6

𝑍2 =

𝑅2
1 + 𝑗𝐶𝑅2 ω

On applique alors le théorème de superposition pour trouver la tension sur e- :
e− =

𝑈𝑆 ∗ 𝑅1 + 𝑈𝐸 ∗ 𝑍2
𝑅1 + 𝑍2

L'entrée non-inverseuse étant branchée à la masse, on a alors e+ = 0. Or, e+ =e-, on peut donc écrire :
𝑈𝑆 ∗ 𝑅1 + 𝑈𝐸 ∗ 𝑍2 = 0
𝑈𝑠 ∗ 𝑅1 = −𝑈𝐸 ∗ 𝑍2

𝑈𝑠 ∗ 𝑅1 =

−𝑈𝐸 ∗ 𝑅2
1 + 𝑗𝐶𝑅2 ω

𝑅
− 2
𝑈𝑆
𝑅1
𝑇𝑉 =
=
𝑈𝐸
1 + 𝑗𝐶𝑅2 ω

Il faut alors identifier la fréquence de transition f 0 et l'amplification A 0 :
Identification de f 0 :
𝑗

ω
= 𝑗𝐶𝑅2
ω0

𝑓0 =

1
2𝜋𝑅2 𝐶

Identification de A 0 :

Dimensionnement des composants :

𝐴0 = −

𝑅2
𝑅1

Nous voulons une fréquence de transition de 5Hz et une amplification maximale de 36. Cependant, si
nous dimensionnons les résistances afin d'avoir une amplification d'exactement 36, il se peut qu'avec
la tolérance des résistances calibrées à 5 %, la tension de sortie de l'amplificateur soit supérieure à
5V. Il y aurait alors un risque d’abîmer l'Arduino. Pour éviter cela, nous préférons prendre une
amplification de 33.
Nous choisissons donc R 2 = 330 kΩ et R 1 = 10kΩ. Le rapport des deux résistances nous donne bien
une amplification de 33.
Il reste à dimensionner le condensateur C.

𝐶=

1
2𝜋𝑅2 𝑓0
7

𝐶=

1
2 ∗ 𝜋 ∗ (330 ∗ 103 ) ∗ 5

𝐶 = 96.4 ∗ 10−9 𝐹

Nous de mettre en parallèle 2 condensateurs de 68 nF et 22 nF afin d’avoir la valeur du
condensateur équivalent la plus proche possible de celle calculée. En effet, lorsque des
condensateurs sont branchés en parallèle, leurs valeurs de capacité s’ajoutent. Ici, on a 7,1% d’écart
avec la valeur théorique, mais cela ne pose pas de problème étant donné que les condensateurs
proposés ont une tolérance de 10%.
Il ne reste plus qu'à tester le filtre et voir si on obtient le diagramme de Bode désiré. Pour cela, on
réalise le montage avec les valeurs de composants trouvés plus haut. Nous n’allons pas alimenter le
TL072 avec l’alimentation symétrique de l’ICL 232, mais avec une alimentation symétrique classique
afin d’éviter au maximum les sources d’erreurs. Nous l’alimentons donc en +17V/-17V et appliquons
en entrée un signal sinusoïdal afin d’avoir qu’une fréquence disponible, de valeur moyenne nulle, et
d’amplitude suffisamment faible pour éviter de saturer et ainsi mesurer correctement le rapport
entre Us et Ue.
Le protocole de test d’un filtre passe-bas est assez simple, et il en consiste en 3 points de mesure. A
une décade en dessous de la fréquence de transition, il faut vérifier que le rapport entre Us et Ue est
bien égal à l’amplification (33 ici). On se place ensuite à la fréquence de transition (5Hz) et on vérifie
que 20 ∗ log(𝐴0) -3 dB.. Enfin, on se place à une décade en dessous de la fréquence de transition
(50Hz), et on calcule 20 ∗ log(𝑈𝑠/(𝑈𝑒). Nous devrions trouver 20 ∗ log(𝐴0) -20 dB.

Nous choisissons comme tension Ue un signal sinusoïdal d’amplitude CAC 1V et d’offset nul.
Les résultats des mesures sont regroupés dans le tableau suivant :
Fréquence (Hz)
Us CAC
Tv
TvdB

1
32.5
32.5
30.23

5
22.9
22.9
27.23

50
3.15
3.15
9.96

Les résultats obtenus sont en accords avec ce que nous attendions (cf Annexe 4).
Comme la tension envoyée au filtre par la sonde est positive et que le filtre est inverseur, le
problème était que nous nous retrouvions avec une tension négative sur l’entrée de l’Arduino. Ce
problème était facilement contournable, il suffisait d’utiliser le deuxième AOP présent sur le TL072 et
de le câbler en inverseur avec 2 résistances égales. La sortie du filtre va donc sur l’entrée de
l’inverseur.
Nous avons ensuite testé le système complet, c’est-à-dire avec l’ICL232 qui alimentait le TL072, et la
sonde d’ensoleillement sur l’entrée de l’AOP. Nous ensuite observé le signal obtenu à l’oscilloscope.
Le signal obtenu était extrêmement parasité, mais était supérieur à 0V, ce qui était un premier point
positif. Cela venait du fait que l’ICL232 ne délivre pas une alimentation symétrique continu, mais
alterne entre le +10V de la patte 2 et le -10V de la patte 6. De ce fait, on pouvait observer très
clairement les phases de charge et de décharge des différents condensateurs. Il fallait donc filtrer au
maximum pour avoir un signal le plus constant possible. C’est pourquoi nous avons remplacé les
deux condensateurs de 1 μF par des condensateurs de 470 μF. Lors du deuxième test avec les
nouveaux condensateurs nous avons observé un signal qui était très régulier, et avec quelques

8

parasites de l’ordre du millivolt. Ces parasites n’étaient pas un problème car le CAN de l’Arduino
allait les moyenner. Un dernier problème à résoudre était la présence d’un offset. En effet, lorsque
l’on branchait l’entrée du filtre à la masse, le signal de sortie était à environ un demi-volt, au lieu
d’être à 0V. Cet offset était causé par l’alimentation de l’ICL 232 qui n’était pas exactement
symétrique. C’est pourquoi nous avons branché un pont diviseur de tension avec un potentiomètre
en entrée de la patte e+ du filtre, avec des valeurs de résistance et de potentiomètre très grandes
pour éviter de consommer du courant et éviter une chute de tension trop importante au bornes du
TL072.
Une fois l’offset réglé, nous avons testé à l’oscilloscope et avec une lampe puissante la sonde
d’ensoleillement. Lorsque cette lampe éteinte, nous avions une valeur moyenne de 1 volt observée à
l’oscilloscope. Et lorsque nous allumions la lampe et que nous placions la sonde en face, on observait
une valeur moyenne de 4 volts. Le montage fonctionne bien, il ne reste plus qu’à traiter le signal avec
l’Arduino.

Utilisation de la maquette anémomètre-ventilateur

Le cahier des charges nous impose de mesurer et d’afficher sur l’écran de l’ordinateur la vitesse du
vent. Il faut au préalable étalonner l’anémomètre. Pour cela, il faut générer des vitesses de vent
connues avec le ventilateur. Il faut donc faire varier la tension d’alimentation du ventilateur.
Comment faire pour piloter un moteur à partir de l’Arduino ?
Pour cela, deux solutions s’offrent à nous : la première est de brancher un potentiomètre en série
avec le moteur, et de faire varier la valeur de ce potentiomètre, et donc la valeur du courant dans le
circuit.

Ce n’est pas la solution la mieux adaptée, car la valeur du courant ne peut pas être calculée
précisément avec un potentiomètre. De plus, le pilotage du moteur doit se faire automatiquement,
et le réglage du potentiomètre nécessite une intervention humaine. Ce montage est donc à proscrire.
Une autre solution beaucoup utilisée en électrotechnique pour le pilotage de moteur consiste à
utiliser un transistor et commander celui-ci avec un signal TTL de rapport cyclique variable. Cela
convient parfaitement ici car l’Arduino possède justement un registre et une sortie où l’on peut
régler ce signal facilement : le mode PWM.
Voici le montage associé à la commande d’un moteur à partir de l’Arduino :

9

Il suffit ici de régler le rapport cyclique pour avoir la tension désirée aux bornes du ventilateur grâce à
la formule suivante :
𝑇0
𝑈𝑚𝑜𝑦 = 12 ∗
𝑇

T 0 étant le temps à l’état haut, T la période du signal, et 12 la tension d’alimentation du système.
Ainsi, le transistor sera saturé pendant un temps correspondant à T 0 , bloqué pendant un temps
correspondant à T-T 0 . Par exemple, si on veut simuler une alimentation de 6 volts aux bornes du
ventilateur, il faut envoyer un signal de rapport cyclique de 50%. Evidemment, pour que la tension
moyenne aux bornes du ventilateur se rapproche le plus possible de la tension désirée, il faut que la
fréquence du signal TTL soit la plus grande possible.

Concernant le fonctionnement de l’anémomètre, il est très simple. Il a besoin d’être alimenté avec
une tension continue de 5V et renvoie un signal TTL dont la fréquence varie avec la vitesse du vent,
mais de rapport cyclique constant.
Le schématic et le board de la carte électronique sont disponibles dans l’annexe 3.

10

Partie Informatique
Pour exploiter les signaux envoyés par les capteurs, un microcontrôleur nous permet de traiter
numériquement les informations afin de pouvoir donner des données plus explicites.

Structures de Données utilisées : Présentation et justification.
Les structures de données nous permettent de regrouper des valeurs qui concernent un
même sujet. Dans notre projet, nous avons notamment un ensemble qui regroupe les valeurs de
OCR2B servant à générer des rapports cycliques, les vitesses de vent (celles données dans l’énoncé),
ainsi que la valeur moyenne de la fréquence relevée grâce à l’anémomètre.
En effet, ces données correspondent à chaque fois à un palier, déterminé physiquement par la
tension. Exemple : Pour une tension de 6V, il nous faudra : - Un rapport cyclique de 50%
- La vitesse de vent associée (énoncé)
-Une fréquence moyenne à relever
Il semble donc judicieux de regrouper ces données dans un structure d’enregistrement, comme cidessous.
typedef struct {
float m_fVitesseVents ;
float m_fValeurMoy ;
int im_iValeursRapportC ;
} TDonnees

Nous avons plusieurs paliers (Sept paliers, de 6V à 12V avec un pas de 1V). Il convient donc de
déclarer un tableau de type TDonnees, qui permettra de stocker ces valeurs de manière à ce que
d’éventuels utilisateurs postérieurs sachent que ces données sont liées entre elles.
TDonnees enrTabMain [TAILLE] = {{2.8, 0,128}, {…}} ;

Nous avons bien sur défini l’équivalence syntaxique #define TAILLE 7.
#define TAILLE 7 ;
Un dernier tableau a été créé, il contient les valeurs des pentes entre les différents paliers. Nous ne
l’avons pas rattaché à la structure d’enregistrement car ce tableau contiendra une valeur de moins,
et les pentes ne correspondent pas à un palier mais à un intervalle entre deux paliers.
TDonnees enrTabMain [TAILLE] = {{2.8, 0,128}, {…}} ;
11

Découpage du Programme en fonctions
Notre programme (Fonctions d’initialisation mises à part) comporte 4 fonctions principales
(loop compris) ainsi que deux interruptions. Nous avons fait figurer les interruptions sur le schéma
bloc, car elles sont indispensables au fonctionnement du programme.

Explication du Déroulement du Programme
Après avoir déclaré les variables globales (principalement utilisées pour les fonctions
d’interruptions) et après avoir appelé toutes les fonctions d’initialisation dans le setup, notre
programme arrive dans le loop. Notre système est combinatoire : pour l’appui sur le bouton
poussoir, qu’on appellera BP0, on lance la fonction d’étalonnage de l’anémomètre. Cette fonction va
générer, grâce au mode PWM, un signal TTL dont le rapport cyclique varie selon des valeurs que nous
avons auparavant calculées pour obtenir les tensions voulue. Ainsi, nous pouvons relever la
fréquence de l’anémomètre correspondante (le signal provenant de l’anémomètre est un signal TTL
dont la fréquence varie). Pour plus de précision, nous avons fait dix mesures puis un calcul de la
valeur moyenne. A partir de ces différentes données, nous calculons une pente entre chaque point,
ce qui correspond à une interpolation linéaire. Nous calculons également l’ordonnée à l’origine,
indispensable pour avoir de bonnes valeurs.

12

Dans cette fonction d’étalonnage, les fréquences sont relevées grâce à deux interruptions :
une première sur interruption externe, qui compte tous les fronts du signal et incrémente un
compteur qui sert de condition pour qu’après trois fronts, soit une période, le registre TCNT0 soit
remis à 0. Ce registre nous permet donc d’obtenir la fréquence, mais comme il est sur 8bits et que la
fréquence de l’anémomètre varie de 10Hz à 30Hz environ, il faut prêter attention à d’éventuels
débordements du registre. Nous avons choisi le prescaler le plus grand possible pour essayer de
supprimer les débordements, mais cela ne suffisait pas. L’horloge interne est de 16MHz, avec un
prescaler de 1024 :
16. 106
= 15625 𝐻𝑧
1024

On compte donc à 15 625Hz, ce qui nous donne un période de :
1
= 64 µ𝑠
15625

Notre fréquence, au maximum, aura une période de :

1
= 33.3 𝑚𝑠
30

Donc sur une période de notre signal, le registre TCNT0 s’incrémentera de :
33.3. 10−3
≈ 520
64. 10−6

Il débordera donc forcément, il est nécessaire d’implémenter une seconde interruption sur
débordement de ce registre afin de pouvoir compter son nombre de débordement et pouvoir
calculer la bonne fréquence en conséquence, en multipliant le nombre de débordement par la valeur
maximum du registre, soit 255.
Lorsque cette fonction d’étalonnage est terminée, on retourne dans le loop, qui va alors
appeler la fonction du CAN, qui va retourner la valeur de l’ensoleillement en W/m². Pour que le CAN
retourne une valeur en W/m² et non pas une valeur « abstraite » comprise entre 0 et 255 (car le
convertisseur est sur 8 bits), nous avons fait un simple calcul pour savoir à combien l’incrémentation
de 1 du registre du CAN correspondait en W/m². On admet une tension maximale de 5 Volts, que l’on
considère pour un ensoleillement maximal de 2000 W/m².
On a donc :
5
= 19.5𝑚𝑉
255

Une variation du registre correspond donc à une variation de :
2000 ∗ 19.5 ∗ 10−3
≈ 7.8 W/m²
5

On multiplie donc le registre du CAN par cette valeur pour obtenir une unité de sortie en W/m².

13

Une valeur aléatoire de rapport cyclique va être générer grâce à la fonction arduino random() ; pour
le registre OCR2B, pour faire en sorte que le ventilateur génère des vents différents.
Le programme passe ensuite dans une série de structures de choix pour isoler l’intervalle sur lequel
se trouve la fréquence et ainsi calculer la vitesse du vent avec la bonne pente.

Explication des initialisations des registres particuliers
Fonction InitCan :
𝑨𝑫𝑴𝑼𝑿 = 𝟎𝒃𝟎𝟏𝟏𝟎𝟎𝟏𝟎𝟏;

BIT 7:6 – Sélection de la tension de la référence : V REF = V CC
BIT 5 – Mise à 1 afin d’ajuster à gauche le résultat. On lira donc simplement le registre ADCH (Nous
ne nécessitons que 8bits) et le registre de données ADC sera remis à jour.
BIT 4 – Bit inutilisé ; sera toujours à 0.
BIT 3:0 – Sélection de l’entrée (PC5).
𝑨𝑫𝑪𝑺𝑹𝑨 = 𝟎𝒃𝟏𝟎𝟎𝟎𝟎𝟏𝟎𝟎

BIT 7 – Mise à 1 pour activer ADC, et donc autoriser les conversions.
BIT 6 – Mis à 0 ici, il sera mis à 1 dans la fonction ConvAn8Bit lorsque l’on voudra démarrer une
conversion.
BIT 5:3 – Concernent le trigger/interruptions ; Désactivés.
BIT 2:0 – Sélection du prescaler à 32 : Période de scrutation plus grande.
𝑨𝑫𝑪𝑺𝑹𝑩 = 𝟎

BIT 7, 5:3 – bits réservés, doivent être mis à 0.
BIT 6 – Autorise une fonction pour remplacer l’input du CAN ; Désactivé (mis à 0).
BIT 2:0 – Concernent un auto trigger ; désactivé.

Fonction InitTimer2 :
𝑻𝑪𝑪𝑹𝟐𝑨 = 𝟎𝒃𝟎𝟎𝟏𝟎𝟎𝟎𝟏𝟏

BIT 7:6 – Concernent un OC2A, non utilisé dans notre cas; mis à 0.
BIT 5:4 – En mode fast-PWM, on choisi le débordement à 255.
BIT 3:2 – Réservés, doivent être mis à 0.
BIT 1:0 – Sélection du mode fast-PWM.
𝑻𝑪𝑪𝑹𝟐𝑩 = 𝟎𝒃𝟎𝟎𝟎𝟎𝟎𝟎𝟏
BIT 7:6 – Sont concernés uniquement en non-PWM ; Désactivés.
BIT 5:4 – Réservés, doivent être mis à 0.
BIT 3 – Configure le mode fast-PWM.
BIT 2:0 – Sélection du prescaler à 0. Plus la fréquence PWM est importante moins le moteur aura de
coupures.

14

𝑻𝑪𝑵𝑻𝟐 = 𝟎
𝑶𝑪𝑹𝟐𝑨 = 𝟎
TCNT2 est utilisé par le timer, influe sur la fréquence ce qui n’est pas utile pour notre signal. Il est
initialisé à 0 et ne changera pas.
OCR2A n’est pas utilisé pour la génération du signal PWN et est donc initialisé à 0.

Fonction InitTimer0 :
𝑻𝑪𝑪𝑹𝟎𝑩 = 𝟎𝒃𝟎𝟎𝟎𝟎𝟎𝟏𝟎𝟏

BIT 7:6 – La comparaison sur sortie (Output Compare) n’est pas une fonction requise pour ce timer.
BIT 5:4 – Réservés, doivent être mis à 0.
BIT 3 - « Waveform generation » Ne nous est pas utile, est mis à 0.
BIT 2:0 –Prescaler à 1024, pour limiter les débordements sur TCNT0 (ne sera pas suffisant).

Le registre de comptage est initialisé à 0.

𝑻𝑪𝑵𝑻𝟎 = 𝟎

𝑻𝑪𝑪𝑹𝟎𝑨 = 𝟎
On souhaite un fonctionnement sans mode spécial, tout le registre est mis à 0.
𝑻𝑰𝑴𝑺𝑲𝟎 = 𝟎
On ne veut pas d’interruptions sur le timer0, le registre sera donc mis à 0.

Fonction InitPorts
𝐷𝐷𝑅𝐷 = 𝐷𝐷𝑅𝐷 &(~ 𝐵𝐼𝑇4) | 𝐵𝐼𝑇3

Nous avons placé le signal de l’anémomètre sur PD4, qui prendra les interruptions externes, et donc
configurée en entrée.
Le signal PWM généré sera placé sur PD3, configurée en sortie.
𝐷𝐷𝑅𝐶 = 𝐷𝐷𝑅𝐶 &(~𝐵𝐼𝑇5)

Signal de la cellule photovoltaïque en entrée sur PC5.

Présentation des résultats
La fonction Convertisseur analogique/numérique fonctionne correctement. Pour le tester,
nous avons tout d’abord relié une alimentation sur l’entrée du CAN. En faisant varier cette
alimentation de 0 Volts jusqu’à 5V, nous avons tout d’abord rencontré un problème avec les valeurs
en sortie du convertisseur, qui étaient instables. Après avoir vérifié les initialisations, nous avons
essayé de changer le bloc périphérique des entrées-sorties de l’Arduino pour un autre, et le
convertisseur a alors bien renvoyé des valeurs variant sur la plage totale désirée. Une fois ce test
effectué, nous avons branché notre cellule photovoltaïque, pour savoir si l’association
Cellule/Carte/Convertisseur fonctionnait correctement. Nous avons placé la cellule à l’obscurité, et
utilisé la lampe qui servait à un projet adjacent pour tester la luminosité qui, après visualisation sur
l’oscilloscope, équivalait à 4V après l’amplification de la carte réalisée.

15

Source d’entrée
Alimentation 0V/5V
Cellule Photovoltaïque

0V - Obscurité
0
≈40

5V – Exposée à la lumière
255
≈200

Les valeurs obtenues sont très satisfaisantes, et montrent bien que le convertisseur analogique
numérique fonctionne correctement.
La fonction d’étalonnage fonctionne en partie. Nous avons rencontré plusieurs problèmes
notamment liés aux interruptions. Nous ne disposions sur le bloc périphérique d’entrées-sorties de
l’Arduino uniquement de quatre douilles. Nous avons réservé la sortie PD3 pour le PWM, réalisé avec
le TIMER2, PC5 en entrée pour le CAN. Il ne nous restait ainsi que PD4 et PC4, ne nous laissant plus
le choix pour le timer à utiliser pour réaliser les interruptions. En effet, sur ces pattes, les
interruptions ne sont réalisables qu’avec le TIMER0. Or, une fois ces interruptions codées, nous nous
sommes rendus compte que les fonctions millis() et micros() étaient déjà associées au TIMER0. Nous
avons donc du retrouver ces fonctions dans un fichier <wiring.c> et mettre en commentaire les
déclarations et définitions de ces fonctions pour qu’il n’y ait aucun conflit. La première fonction
d’interruption externe a alors fonctionné. Nous avons pu le vérifier car le registreTCNT0
s’incrémentait alors qu’il restait à zéro auparavant, cependant les débordements ne sont toujours
pas pris en compte.

16

Conclusion

The main requirements of our project are filled:
The electrical signal emitted by the light sensor has been “shaped” so as to extract reliable
information from it, the analog to digital converter programmed on the Arduino is working
well.
The computer program that references the frequency sent by the anemometer just has one
point that is not working (an interruption) probably because of other functions used with the
timer0. Anyway, the rest of this function is programmed in a pretty efficient way: we use a
linear interpolation to calculate the frequency, in order to have more accuracy.
All the components have been transferred on a board which is quite compact, and this board
also includes a small upgrade: We don’t need an outside supply (+5 /-5 V) for our
Operational amplifier since it’s created from the Arduino supply.
This project taught us to take some time to understand what we’re expected to do, we could
meet deadlines despite delays we encounter by working together, splitting the work or
associating our knowledge to get through problems.

17

Weather Plant
Abstract

The specification of the weather plant project is to measure and display on the computer
screen the wind speed and the intensity og the sunshine with an Arduino and a C program.
For the wind speed, we will use a system composed of a computer fan and an
anemometer: the blower simulates the wind, and the anemometer, fixed in front of the
blower, delivers a TTL signal that has a frequency which depends on the wind speed. Before
measuring the wind speed, an automatic calibration of the anemometer must be done with
an electronic control system of the fan.
For the intensity of the sunshine, we used a PV cell. We filter above 5Hz the signal
delivered by the cell, and amplify it to have a voltage between 0 and 5V, workable by the
Arduino. We used a TL72, capacitors and resistors to amplify and filter the signal. We used a
component named ICL232.
Keywords

#Weather
#Arduino
#Symmetrical Supply
#Calibration
#Printed Circuit

18


Aperçu du document Rapport_Geiger_Jovet.pdf - page 1/19
 
Rapport_Geiger_Jovet.pdf - page 3/19
Rapport_Geiger_Jovet.pdf - page 4/19
Rapport_Geiger_Jovet.pdf - page 5/19
Rapport_Geiger_Jovet.pdf - page 6/19
 




Télécharger le fichier (PDF)


Télécharger
Formats alternatifs: ZIP



Documents similaires


rapport geiger jovet
arduino  led eclairage velo v2
singo
codes defauts bosch edc15c2
arduino partie 4
rta m20 et m50 suite

Sur le même sujet..




🚀  Page générée en 0.222s