Capteurs santé environnementale

De Les Fabriques du Ponant
Aller à : navigation, rechercher

Cette page est une fiche écrite dans le cadre de l'Inter Semestre ENIB 2017

Le contenu de cette fiche est en cours de rédaction, elle va s'étoffer pendant tout le mois de janvier !

Le capteur de santé environnementale

Avez-vous des problèmes d'humidité dans votre lieu de vie ?

Avez-vous froid alors que la température est correcte ?

Le capteur de santé environnementale enregistre la température et l'humidité en continue sur une carte SD, et affiche en temps réel l'état de ces paramètres.

Auteurs

Ont participé à la rédaction de cette fiche :

Du groupe B :


Outils et matériaux

Enregistrement des données :
Photo-CarteGenuino-CE2017.jpg
  • 1 carte Arduino UNO et son câble USB


  • 1 NodeMCU (lecteur de carte SD)
    Photo-NodeMCU-CE2017.jpg


  • 1 capteur DHT22

Photo-CapteurDHT22-CE2017.jpg


  • 1 Carte SD
  • 1 alimentation USB ou alimentation prise

Affichage par leds :

  • 6 Leds (2 vertes, 2 rouges, 2 jaunes)
  • 1 Résistance d'environ 200 Ohm (une résistance plus faible augmentera l'intensité lumineuse des leds et la puissance consommée)
  • Quelques câbles électriques
  • 1 Plaque à trou
  • de l'étain

Photo-LedResistance-CE2017.jpg

Outils utilisés

  • Pince à dénuder ou pince coupante ou cutter
  • Découpeuse laser
  • Fer à souder
  • Ordinateur
  • Logiciel Arduino
  • Logiciel Inkscape
  • Page web pour le traitement des données

Fichier:Capteur sante afficheur.zip

Réaliser le projet

Câblage des cartes et du capteur

1° Assembler la carte arduino et la NodeMCU

2° Brancher le capteur : Le câble rouge sur le 3,3V ( + ); Le câble noir sur le GND ( - ); Le câble marron sur le Pin 2 ( Données ).

Câblage des leds

1° Positionner les leds et la résistance sur la plaque à trou.
2° Souder les cathodes ensemble à une patte de la résistance, l'autre étant reliée à la masse.
Laisser les anodes à l'air libre pour les relier à la carte arduino.
3° Câbler les anodes sur les ports indiqués dans le programme.

SchemaLed-Projet-CE2017.png

Création du programme

1° Télécharger les outils Arduino et les bibliothèques associées au capteur et à la carte.

  • Logiciel Arduino : Génuino IDE
  • Bibliothèques :
    Arduino ideBiblio Projet-CE2017.png
    • Arduino AVR Boards
    • Adafruit Unified Sensor
    • DHT sensor library
    • SD (pas la dernière version : Nous avons utilisé la version .4)
    • RTClib adafruit

On les retrouve dans "Croquis" puis "Inclure une bibliothèque" et "Gérer les bibliothèques"

2° Tester les périphériques

Utiliser les codes exemple pour tester les fonctionnalités du capteur et de la carte SD.

Pour faire le programme, on part donc de ces fichiers d'exemple pour comprendre comment se servir des composants :

  • Ici, il faut pouvoir ouvrir la carte SD, ouvrir un fichier dessus grâce aux codes de la bibliothèque SD.
  • Il faut aussi pouvoir récupérer la température et le taux d'humidité avec les exemples des bibliothèques 'Adafruit Unified Sensor' et 'DHT sensor library'.
  • Si on veut une mesure plus précise du temps, on peut aussi utiliser l'horloge RTC intégrée au shield. Il faut pour cela se baser sur la 'RTClib adafruit'.

3° Ecrire le code

Arduino lib path Projet-CE2017.png
// Carte SD :
#include <SPI.h>
#include <SD.h>

// Capteur :
#include <Adafruit_Sensor.h>
#include <DHT.h>
#include <DHT_U.h>

// Horloge :
#include <Wire.h>
#include "RTClib.h"

// Pin des DEL :
#define LED_GOOD_TEMP     3
#define LED_MEDIUM_TEMP   4
#define LED_BAD_TEMP      5

#define LED_GOOD_HUM    6
#define LED_MEDIUM_HUM  7
#define LED_BAD_HUM     8

// Pin du capteur
#define CS_PIN            10
#define DHTPIN            2
#define DHTTYPE           DHT22

// Intervales de qualité :
const char GOOD_TEMP[2] =   {18,20};         
const char MEDIUM_TEMP[2] = {15,23};
const char GOOD_HUM[2] =  {45,65};
const char MEDIUM_HUM[2] = {30,80};

// Temps entre chaque mesure :
#define DELAY             5*60 // En secondes

// Autres variables.
File f;
String output = {""};

// On indique qu'elle broche est utilisée pour le capteur.
DHT_Unified dht(DHTPIN, DHTTYPE);

// Variable de l'horloge :
RTC_DS1307 rtc;

// En cas d'erreur, on allume toutes les DEL, et on bloque le programme :
void erreur(void) {
    digitalWrite(LED_GOOD_TEMP, HIGH);
    digitalWrite(LED_MEDIUM_TEMP, HIGH);
    digitalWrite(LED_BAD_TEMP, HIGH);
    digitalWrite(LED_GOOD_HUM, HIGH);
    digitalWrite(LED_MEDIUM_HUM, HIGH);
    digitalWrite(LED_BAD_HUM, HIGH);
    while(1);
}

void setup() {
  // Initialisation de la communication série (pour le moniteur série du logiciel Arduino) :
  Serial.begin(9600);

  // On essaye d'ouvrir la carte SD :
  if (!SD.begin(CS_PIN)) { // Doc
    Serial.println("Erreur avec la carte SD !");
    erreur();
  }
  Serial.println("Card initialisée.");

  // Initialisation de l'horloge :
  if (! rtc.begin()) {
    Serial.println("Impossible de trouver l'horloge RTC");
    erreur();
  }
  if (! rtc.isrunning()) {
    Serial.println("L'horloge RTC n'est PAS lancée !");
    // Règle l'horloge avec l'heure de la compilation :
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

  // Initialisation du capteur :
  dht.begin();

  // On essaye d'ouvrir le fichier :
  if (f = SD.open("DATALOG.TXT",FILE_WRITE)) {
    Serial.println("Fichier ouvert.");  // On affiche les informations des capteurs :
    sensor_t sensor;
    dht.temperature().getSensor(&sensor);
    f.println("------------------------------------");
    f.println("Temperature");
    f.print  ("Sensor:       "); f.println(sensor.name);
    f.print  ("Driver Ver:   "); f.println(sensor.version);
    f.print  ("Unique ID:    "); f.println(sensor.sensor_id);
    f.print  ("Max Value:    "); f.print(sensor.max_value); f.println(" *C");
    f.print  ("Min Value:    "); f.print(sensor.min_value); f.println(" *C");
    f.print  ("Resolution:   "); f.print(sensor.resolution); f.println(" *C");  
    f.println("------------------------------------");
    
    dht.humidity().getSensor(&sensor);
    f.println("------------------------------------");
    f.println("Humidity");
    f.print  ("Sensor:       "); f.println(sensor.name);
    f.print  ("Driver Ver:   "); f.println(sensor.version);
    f.print  ("Unique ID:    "); f.println(sensor.sensor_id);
    f.print  ("Max Value:    "); f.print(sensor.max_value); f.println("%");
    f.print  ("Min Value:    "); f.print(sensor.min_value); f.println("%");
    f.print  ("Resolution:   "); f.print(sensor.resolution); f.println("%");  
    f.println("------------------------------------");
    // On referme le fichier à la fin :
    f.close();
  }
  else {
    Serial.println("Erreur : Impossible d'ouvrir DATALOG.TXT !");
    erreur();
  }

  // On défini les pins reliées aux DEL comme étant des sorties :
  pinMode(LED_GOOD_TEMP, OUTPUT);
  pinMode(LED_MEDIUM_TEMP, OUTPUT);
  pinMode(LED_BAD_TEMP, OUTPUT);
  pinMode(LED_GOOD_HUM, OUTPUT);
  pinMode(LED_MEDIUM_HUM, OUTPUT);
  pinMode(LED_BAD_HUM, OUTPUT);
}

void loop() {
    output = "";
    // On génère la partie date du message :
        DateTime now = rtc.now();
        output += now.day();
        output += '/';
        output += now.month();
        output += '/';
        output += now.year();
        output += " ";
        output += now.hour();
        output += ':';
        output += now.minute();
    // On génère la partie température du message :
      sensors_event_t event;
      // On récupère la température :
      dht.temperature().getEvent(&event);
      // On teste si elle a pu être faire :
      if (isnan(event.temperature)) {
        output += " , Error reading temperature!";
      }
      else {
        output += " , ";
        output += event.temperature;

        // On éteint les DELS :
        digitalWrite(LED_GOOD_TEMP, LOW);
        digitalWrite(LED_MEDIUM_TEMP, LOW);
        digitalWrite(LED_BAD_TEMP, LOW);
        // On rallume celle qui correspond à l'intervalle de qualité de la mesure :
        if (event.temperature > GOOD_TEMP[0] && event.temperature < GOOD_TEMP[1]) digitalWrite(LED_GOOD_TEMP, HIGH);
        else if (event.temperature > MEDIUM_TEMP[0] && event.temperature < MEDIUM_TEMP[1]) digitalWrite(LED_MEDIUM_TEMP, HIGH);
        else digitalWrite(LED_BAD_TEMP, HIGH);
      }
      
    // On génère la partie température du message (idem que pour la température) :
      dht.humidity().getEvent(&event);
      if (isnan(event.relative_humidity)) {
        output += " , Error reading humidity!" ;
      }
      else {
        output += " , ";
        output += event.relative_humidity;
        
        digitalWrite(LED_GOOD_HUM, LOW);
        digitalWrite(LED_MEDIUM_HUM, LOW);
        digitalWrite(LED_BAD_HUM, LOW);
        if (event.relative_humidity > GOOD_HUM[0] && event.relative_humidity < GOOD_HUM[1]) digitalWrite(LED_GOOD_HUM, HIGH);
        else if (event.relative_humidity > MEDIUM_HUM[0] && event.relative_humidity < MEDIUM_HUM[1]) digitalWrite(LED_MEDIUM_HUM, HIGH);
        else digitalWrite(LED_BAD_HUM, HIGH);
      }
    // On ouvre le fichier pour écrire dedans et on le referme :
    if (f = SD.open("DATALOG.TXT",FILE_WRITE)) {
      f.println(output);
      f.close();
    }
    else {
      Serial.println("Error opening file !");
    }
    // On affiche les mesures dans le port série :
    Serial.println(output);
  // On attend le nombre de secondes spécifiées dans le DELAY :
  for (int i = 0; i < DELAY ; i++)
    delay(1000);
}

Création du boitier

1° Prendre les dimensions de la carte et des périphériques.


2° Réaliser la pièce sur un logiciel de dessin vectoriel. Ici nous utilisons Inkscape.

Avec les extensions installées sur les PC des fabriques du ponant, nous téléchargeons un fichier de boîte à encoche. Nous choisissons des encoches de 10 mm, une largeur de 80mm, une hauteur de 100mm et une profondeur de 60mm.

Nous décidons de réaliser 6 trous de 5mm de diamètre pour le passage des del, que nous dessinons sur un grand côté. Nous y ajoutons du texte à graver "Température", "Humidité", "idéale", "correcte", "mauvaise".

Au dos nous créons une spirale pour laisser passer l'humidité.

Et sur un des petits côtés nous ajoutons deux rectangles à découper pour avoir accès à la carte SD et au port USB de la carte arduino.

Inkscape boitierschema projet-CE2017.png

3° Convertir le fichier afin de le rendre compatible à la découpeuse laser.


4° Lancer la découpe.

Photo-boitier-apresDecoupe Projet-CE2017.jpg

Assemblage

Après avoir récupéré toutes les pièces, on peut finir de câbler les del à la carte arduino. Assembler les 3 côtés et le socle du boitier (voir photo) et y mettre des points de colle chaude. On y place les cartes, les del et le capteur. Puis on finit d'assembler le boitier.

Interieurboitier projet-CE2017.jpg


Photo-boitierFermeLed Projet-CE2017.jpg PhotoBoitierFermeDos Projet-CE2017.jpg

Mise en marche

Une fois les étapes précédentes finies, il suffit de brancher la carte soit à un ordinateur, soit sur un adaptateur secteur USB (par exemple celui d'un smartphone) ou une batterie 9V (comme les chargeurs portables de smartphone). Lorsqu'elle est branchée, le programme démarre de lui-même.

Comment ça marche ?

Observations

BoitierAllume Projet-CE2017.jpg

Lorsque le capteur est allumé on observe que les leds sont allumées , une pour la température et une pour l'humidité.

On voit qu'il y a 3 niveaux différents : Bon, Moyen et Mauvais.

Sur le côté du boitier on voit une carte SD et un câble de branchement USB.

Explications

La carte arduino permet de récupérer les données du capteur (humidité et température), un programme permet d'afficher les données en temps réel sur les del et au même moment il les enregistre sur la carte SD.

Les DEL indique les niveaux de température :

Bon : 18-20

Moyen : 15-18 et 20-23

Mauvais : inférieur à 15 et supérieur à 23


Les niveaux d'humidité :

Bon : 45-65

Moyen : 30-45 et 65-80

Mauvais : inférieur à 30 et supérieur à 80


Par la suite on peut afficher les données avec la page web en ouvrant le fichier home.html (voir : outils).

On doit récupérer le ficher DATALOG.TXT sur la carte SD

Graph.png

Plus d'explications

Fonctionnement des capteurs :

  • Capteur d'humidité : Il s'agit d'un capteur de type hygromètre, les hygromètres électroniques sont basés sur la modification de la valeur d'un condensateur en fonction de l'humidité. Plus précisément, le diélectrique du condensateur (liquide contenu entre les deux électrodes du condensateur) est sensible à l'humidité relative de l'air et selon cette humidité il change le temps de charge du condensateur. L'analyse de ce temps temps de charge permet de connaitre le taux d'humidité dans l'air.
  • Capteur de température : Le capteur utilisé est simplement une thermistance, il s'agit d'une résistance dont l'impédance (ou résistance) change selon la température ambiante. En alimentant cette thermistance avec une tension connue on peut retrouver la température par lecture du courant de sortie (U = R*I).

Et dans la vie de tous les jours ?

Cela permet de visualiser l'évolution de la température et de l'humidité d'un lieu de vie au cours de la journée et de repérer les endroits particulièrement humides ou mal isolés.

Vous aimerez aussi

Liens vers des projets ou des expériences complémentaires pour mieux comprendre son fonctionnement.

Compteur ultrasons de visiteurs

Sources et ressources utiles

Liens vers les ressources pédagogiques + quelques mots de description si besoin