Capteurs santé environnementale

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 :

• Klervi
• Guillaume
• Willy
• Florent

Outils et matériaux

Enregistrement des données :

• 1 carte Arduino UNO et son câble USB

• 1 NodeMCU (lecteur de carte SD)
  

• 1 capteur DHT22

• 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

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

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 ensembles à 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.

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 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 bibiliothèques"

2° Tester les périphériques

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

3° Ecrire le code

// 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é nous ajoutons deux rectangles à découper pour avoir accès à la carte SD et au port USB de la carte arduino.

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

4° Lancer la découpe.

Assemblage

Après avoir récupérer 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 finis d'assembler le boitier.

Mise en marche

Une fois les étapes précédentes finie, 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 portable de smartphone). Lorsqu'elle est branchée, le programme démarre de lui même.

Comment ça marche ?

Observations

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

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

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

Explications

La carte arduino permet de récupéré 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 niveau 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

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 :

Et dans la vie de tous les jours ?

Mettre en avant le lien avec le quotidien.

Cela permet de visualiser l'évolution de la température et de l'humidité 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