Projet IMA3 P2, 2016/2017, TD1 : Différence entre versions
(→Partie informatique) |
(→Partie électronique) |
||
| Ligne 278 : | Ligne 278 : | ||
=== Partie électronique === | === Partie électronique === | ||
| + | |||
| + | Prise en main de Altium designer et réalisation du comparateur de température | ||
=== Partie informatique === | === Partie informatique === | ||
Version du 4 avril 2017 à 09:39
Sommaire
Projet IMA3-SC 2016/2017 : Maison connectée
Cahier des charges
Description du système
- L'écologie étant un point clé des futures années, il nous a semblé intéressant d'associer ce thème aux systèmes communicants. Le but est donc de mener à bien le projet d'une maison intelligente et communicante.
- La maison aura donc diverses fonctions gérées par l'utilisateur à distance, tel que l'éclairage, le chauffage, l'état de ses portes, l'état du garage...
- Tout étant géré à la fois via une interface web et une application Android.
- L'application laissera la possibilité de programmer ses routines afin que la maison devienne par définition autonome.
- Les mouvements dans la maison peuvent être détectés et l'application informe l'utilisateur en cas de mouvements imprévus (alerte voleur !)
Liste des fonctions à réaliser
- Mesure de la température (en °C) et de la luminosité (en lux).
- Détection de mouvement pour l'éclairage et les intrusions.
- Communication des informations sur une page web et une application Android.
- Automatisation de la commande de chauffage et d'éclairage.
- Automatisation des entrées et sorties de la maison (porte de garage..)
- Prévision de la consommation
Le matériel
Pour mener à bien ce projet il nous faudra :
- Raspberry PI3
- Carte SD 8GB
- Arduino Nano
- Servo-moteur
- Capteur de luminosité, capteur de température (pour Arduino)
- 5 leds
- module peltier et un radiateur
- Transformateur 230V/12V
- Relais 3.3V
- Capteur PIR (Passive Infra-Rouge)
- Maquette imprimée en 3D au fabricarium (la modélisation étant réalisée par nos soins.)
Séance 1
Durant cette séance, nous avons consacré notre temps principalement aux tests des différents modules qui s'appareillent avec la carte arduino. Cette étape est très crucial pour avoir un aperçu des caractéristiques de chacun des composants.
Partie électronique
- Pour une prise en main rapide et facile, nous avons tout d'abord utilisé des fonctions basiques en alternant sur les états des pins de l'arduino afin d'allumer et d'éteindre des LEDs qui feront office de lumière dans la maison. Les LEDs seront connectées en série avec une résidence pour ne pas dépasser la tension de seuil. (Tension sortie arduino > tension seuil LED)
- En deuxième test, on a utilisé la photorésistance. Une photorésistance est un composant dont la résistivité dépend de la luminosité ambiante. Pour faire simple, c'est une résistance dont la valeur change en fonction de la lumière qu'elle reçoit. On peut donc utiliser une photorésistance pour mesurer la luminosité ambiante. Voici quelques ordres de grandeurs de l'éclairement lumineux en fonction des endroits :
Nuit de pleine lune : 0,5 lux Rue de nuit bien éclairée :20 à 70 lux Local de vie : 100 à 200 lux Appartement bien éclairé : 200 à 400 lux Local de travail : 200 à 3 000 lux Stade de nuit : 150 à 1 500 lux Extérieur par ciel couvert : 500 à 25 000 lux Extérieur en plein soleil : 50 000 à 100 000 lux
Le but de la démonstration était de tout simplement mesurer la luminosité ambiante d'une pièce et d'envoyer la valeur mesurée vers l'ordinateur via le câble USB et de visualisé la valeur sur le moniteur série. Le schéma de montage est le suivant :
La résistance de 10kOhm en série avec la photorésistance forme un pont de résistance (diviseur de tension). Après compilation et test, voici le résultat obtenu :
N.B. : La valeur mesurée n'a pas d'unité ! C'est une valeur purement indicative. Si on veut mesurer une mesure en lux, il aurait fallu calibrer la photorésistance et intégrer les données de calibration dans le code. Savoir calibrer un capteur n'est pas le but de cette demonstration.
- Nous avons également fait les tests de température sur le capteur de thermique 36GZ qui a les caractéristiques suivantes :
- Tension d'entrée: 2,7 à 5,5 Vcc - 10 mV/°C - Précision: ±2°C - Linéarité: 0,5°C - Plage d'utilisation: -40°C à +125°C
Le but de ce montage sera de tout simplement mesurer la température ambiante de l'atelier et d'envoyer la température en degré Celsius vers l'ordinateur via le câble USB.
- On utilisera un module Peltier pour jouer le rôle du chauffage. L’effet Peltier est le déplacement de chaleurs en présence d’un courant électrique. L’effet se crée entre deux matériaux conducteurs de différentes natures liés par des jonctions. L’une des jonctions se refroidit pendant que l’autre se chauffe.
Le module Peltier transforme le courant électrique une différence de température. Changer la polarité du Peltier permet de refroidir ou chauffer le bloc métallique sur lequel il sera en contact avec de la graisse thermique pour assurer la transformation de la chaleur maximale. Le module Peltier qu'on utilise peut générer un gradient de température allant jusque 70°C et possède les caractéristiques électriques suivantes : une tension d’entrée maximale de 3,8V et une intensité d’entrée de 8,5A.
- Le dernier test de cette séance a été consacré au servomoteur. Les servomoteurs sont des moteurs un peu particuliers, qui peuvent tourner avec une liberté d'environ 180° et garder de manière relativement précise l'angle de rotation que l'on souhaite obtenir. Les servomoteurs ont pour rôles dans cette maquette d'ouvrir et de fermer le volet et la porte du garage. Il suffit de donner une consigne au servomoteur ("reste à 45°" par exemple) et le servomoteur fera son maximum pour rester au plus près de cette consigne. Voici le schéma de montage du servomoteur avec la carte arduino :
Il est très important et crucial de bien brancher la broche "pulse" du servomoteur sur une pin PWM de la carte (Pulse Width Modulation, pin P9 sur le schéma par exemple). La consigne est transmise au moyen d'un signal numérique, d'une impulsion pour être précis.
Pour que le servomoteur reste à une position donnée, il faut transmettre toutes les 20 millisecondes (soit à une fréquence de 50Hz) une impulsion d'une longueur comprise entre 1 et 2 millisecondes.
Une impulsion de 1 milliseconde correspond à un angle de 0°.
Une impulsion de 2 millisecondes correspond à un angle de 180°.
En envoyant une impulsion d'une longueur intermédiaire, on obtient des angles différents, 90° avec une impulsion de 1.5 milliseconde par exemple.
N.B. La plupart des servomoteurs fonctionnent en 5 volts, mais certains fonctionnent en 3.3 volts. Pensez à bien lire la documentation du servomoteur avant de l'utiliser.
Partie informatique
- Afin d'allumer et d'éteindre les LEDs, il faut tout d'abord initialiser le pin en question en sortie. Pour allumer la LED, on met le pin à l'état haut pour une durée de 5000 cycles qui équivaut à 1 seconde et pour l'éteindre on effectue les mêmes instructions en mettant le pin à l'état bas.
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
pinMode(2, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
digitalWrite(2, HIGH); // turn the LED on (HIGH is the voltage level)
delay(5000); // wait for a second
digitalWrite(2, LOW); // turn the LED off by making the voltage LOW
delay(5000); // wait for a second
}
- Pour le capteur de température, l'arduino reçoit une tension. On multiplie la valeur reçue par la valeur de l'alimentation qui est de 5V. On divise par 1024 cette valeur. 1024 est le nombre d'octet sous lequel est codé la précision du capteur de température.
//TMP36 Pin Variables
int sensorPin = 0; // the analog pin the TMP36's Vout (sense) pin is connected to
// the resolution is 10 mV / degree centigrade with a
// 500 mV offset to allow for negative temperatures
void loop() // run over and over again
{
//getting the voltage reading from the temperature sensor
int reading = analogRead(sensorPin);
// converting that reading to voltage, for 3.3v arduino use 3.3
float voltage = reading * 5.0;
voltage /= 1024.0;
// print out the voltage
Serial.print(voltage); Serial.println(" volts");
// now print out the temperature
float temperatureC = (voltage - 0.5) * 100 ; //converting from 10 mv per degree wit 500 mV offset
//to degrees ((voltage - 500mV) times 100)
Serial.print(temperatureC); Serial.println(" degrees C");
- Pour la photorésistance, le principe étant de lire l'information qui arrive sur la broche à laquelle est branché le module. Pour cela, une acquisition continue avec un écart de 250ms suffira dans notre cas.
// Fonction setup(), appelée au démarrage de la carte Arduino
void setup() {
// Initialise la communication avec le PC
Serial.begin(9600);
}
// Fonction loop(), appelée continuellement en boucle tant que la carte Arduino est alimentée
void loop() {
// Mesure la tension sur la broche A0
int valeur = analogRead(A0);
// Envoi la mesure au PC pour affichage et attends 250ms
Serial.println(valeur);
delay(250);
}
- Le module Peltier fonctionne en continue sans réel consigne c'est à dire qu'il suffira de jouer sur l'état d'un interrupteur pour qu'il chauffe ou pas. Il sera alimenté par une source de tension externe car l'arduino ne répond pas aux besoin nécessaire du module.
- Le dernier module programmé est le servomoteur, la valeur de l'angle est entre 0° et 179°, le résultat sera entre 1 000 et 2 000 microsecondes (donc entre 1 et 2 millisecondes). Grâce à cette formule, on peut obtenir toutes les valeurs d'impulsions pour des positions entre 0° et 179°. Ce programme est un programme test pour comprendre le bon fonctionnement d'un servomoteur.
int periode=20000;// période entre chaque début d'impulsion en microsecondes
int pinServo=8; // variable pour le pin connecté à la commande du servo
void setup() {
pinMode(pinServo,OUTPUT);// on prépare le pin en mode OUTPUT
digitalWrite(pinServo,LOW); // on l'initialise à l'état bas
}
//boucle principale
void loop() {
for (int angle=0;angle<=180;angle+=20){//on fait varier l'angle de 0 à 180° par tranche de 20°
setAngle(angle);// on appelle la fonction setAngle définie plus bas
}
}
//fonction setAngle pour envoyer les impulsions
void setAngle(int a){
int duree=map(a,0,179,1000,2000);// on transforme l'angle en microsecondes et on stocke dans la variable duree
digitalWrite(pinServo,LOW);//on met le pin à l'état bas
// la boucle qui suit est nécessaire
// pour laisser le temps au servo d'aller à sa position
for (int t=0;t<300;t++){
digitalWrite(pinServo,HIGH);// on envoie l'impulsion
delayMicroseconds(duree); // pendant la bonne durée
digitalWrite(pinServo,LOW); // on stoppe l'impulsion
delayMicroseconds(periode-duree); // on attend le temps restant pour atteindre la période
}
}
- En parallèle avec ce travail de programmation sur arduino, on réalise des plans de la maquette de la maison pour ensuite la faire passer à la découpeuse laser grâce au logiciel inkscap.
Séance 2
Partie électronique
- Un capteur infrarouge permet de détecter un mouvement dans son champ de vision en se basant sur l’infrarouge. On parle aussi de capteur pyroélectrique ou PIR. Les PIR sont capable de détecter une variation des ondes infrarouges, ce qui génère un courant électrique. Dans le cas de notre capteur, il est en fait divisé en deux partie différente reliées ensemble afin de détecter une variation lors qu’une des moitiés capte plus qu’une autre. On a ainsi un relevé d’une différence, et non plus d’une valeur simple. Lors d’un mouvement, la variation des deux moitiés vont varier, et on va donc capter cette variation positive.
Les spécifications techniques du capteur PIR HC SR501 sont les suivantes :
Entrée : Tension continue de 4.5 à 20V , courant 65mA Sortie : High 3.3 V / Low 0V (Détection ou non) Angle : <100 ° Dimension : 32 mm * 24 mm Délai : de 5 à 200 secondes (ajustable) Portée : de 3 à 7 mètres (ajustable). Au repos : 50 uA
En ce qui concerne le montage, on s'aide d'une LED pour vérifier l'état et le passage devant le PIR. On branche donc :
Le VCC du PIR sur le 5V de l’arduino Le GRD du PIR sur le GRD de l’arduino La dernière branche sur le pin 2 de l’arduino On ajoute une led de contrôle entre le pin 13 et un GRD de l’arduino
Partie informatique
- Pour la programmation du PIR, il est important de lui laisser au moins 30 secondes pour se calibrer, puis une fois que cela est fait, on va en boucle relever la valeur que nous renvoi le capteur : 0 ou 1. 0 signifiant pas de signal et 1 signifiant qu’il détecte une variation infrarouge. Une LED s'allume pour valider l'état.
//the time we give the sensor to calibrate (10-60 secs according to the datasheet)
int calibrationTime = 30;
int ledPin = 13; // choose the pin for the LED
int inputPin = 2; // choose the input pin (for PIR sensor)
int pirState = LOW; // we start, assuming no motion detected
int val = 0; // variable for reading the pin status
void setup() {
pinMode(ledPin, OUTPUT); // declare LED as output
pinMode(inputPin, INPUT); // declare sensor as input
Serial.begin(9600);
Serial.print("calibrating sensor ");
for(int i = 0; i < calibrationTime; i++){
Serial.print(".");
delay(1000);
}
}
void loop(){
val = digitalRead(inputPin); // read input value
Serial.println(val);
if (val == HIGH) { // check if the input is HIGH
digitalWrite(ledPin, HIGH); // turn LED ON
delay(150);
if (pirState == LOW) {
// we have just turned on
Serial.println("Motion detected!");
// We only want to print on the output change, not state
pirState = HIGH;
}
} else {
digitalWrite(ledPin, LOW); // turn LED OFF
delay(300);
if (pirState == HIGH){
// we have just turned of
Serial.println("Motion ended!");
// We only want to print on the output change, not state
pirState = LOW;
}
}
}
Après avoir compiler et téléverser le programme dans l'arduino, on peut constater dans le moniteur série l'état et le fonctionnement du PIR en directe.
- Le design maquette a été revue en détail durant la séance pour les petites corrections et pouvoir lancer le découpage et ensuite la monter proprement sans soucis de dimensionnement.
Séance 3
Partie électronique
Prise en main de Altium designer et réalisation du comparateur de température
