Capteurs humidité-température lumière et PH

De Centre de Ressources Numériques - Labomedia
Aller à : navigation, rechercher
Capteurs humidité-température lumière et PH
Capt-DHT11-photocell-LCDNokia5110 bb.jpg


Pour modifier la page utiliser l'onglet Modifier avec formulaire.

Résumé réaliser un ensemble de capteurs pour le futur jardin en aquaponie du Labo
Auteur(s) Ségolène
Licence CC-BY-SA 3
Date de création 24 juillet 2017


Intentions / Contexte

Principe de fonctionnement

réunir un ensemble de 4 capteurs : - humidité - température - lumière - PH Capteurs + cable + arduino uno + ecran LCD pour une lecture des données sur un écran LCD

Besoins / Compétences

matéreil : Capteurs température et humidité CYTX DHT11 résistance de 10 KOhm ecran LCD 84x48 nokia 5110 module avec rétroéclairage bleu et adaptateur PBC résistance de 1 KOhm capteur lumière : photoresistance capteur PH : 1 Set Liquide PH 0-14 La Valeur De Détection Capteur Régulateur De Module de Contrôle de Surveillance Mètre Testeur + BNC Électrode de PH sonde Pour Arduino

arduino uno R3 (chinois)avec driver port serie pour Mac : CH341SER_Mac 0xcf.com/2015/03/13/chinese-arduinos-with-ch340-ch341-serial-usb-chip-on-os-x-yosemite/ cable USB (port USB périphérique)

Documentation

Pour commencer il a fallu réunir les capteurs (humidité, température, luminosité) relier à un écran LCD, pour ce faire j'ai fait appel à plusieurs tutoriels en ligne que j'ai associé en un, grâce à l'aide de nombreuses personnes des Open Ateliers version Longue, un grand merci à toutes et tous. voici les références :

tutoriel pour capteur de température et d'humidité DHT11 :

https://www.carnetdumaker.net/articles/utiliser-un-capteur-de-temperature-et-dhumidite-dht11-dht22-avec-une-carte-arduino-genuino/

tutoriel pour capteur de luminosité :

http://www.manuel-esteban.com/arduino-capteur-de-luminosite/

tutoriel pour l'écran LCD Nokia 5110:

https://brainy-bits.com/blogs/tutorials/how-to-use-the-nokia-5110

http://www.wonzer.cn/m/video/u8glib

http://tiptopboards.free.fr/arduino_forum/viewtopic.php?f=2&t=21


Voici le code :

//** inclure une librairie pour l'ecranLCD nokia 5110 (chinois)

  1. include "U8glib.h"

//#include "dht.h" (pas réussi à l'installer)

//#define dht_apin A1

  1. define backlight_pin 11

//dht DHT;

/** Broche "DATA" du capteur */ const byte BROCHE_CAPTEUR = A1; float temperature = 0.0; float humidity = 0.0; /* Code d'erreur de la fonction readDHT11() et readDHT22() */ const byte DHT_SUCCESS = 0; // Pas d'erreur const byte DHT_TIMEOUT_ERROR = 1; // Temps d'attente dépassé const byte DHT_CHECKSUM_ERROR = 2; // Données reçues erronées

const byte photocellPin = A0; //int photocellPin = 0; // the cell and 10K pulldown are connected to a0 int photocellReading; // the analog reading from the analog resistor divider String Lumiere;


// branchements pin

U8GLIB_PCD8544 u8g(8, 4, 7, 5, 6); // CLK=8, DIN=4, CE=7, DC=5, RST=6

// affichage ecran LCD //const uint8_t brainy_bitmap[] PROGMEM = { /* 0x00, 0x00, 0x03, 0xB0, 0x00, 0x00, 0x00, 0x00, 0x07, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x46, 0x00, 0x00, 0x00, 0x00, 0xFC, 0x47, 0xC0, 0x00, 0x00, 0x01, 0xCE, 0x4C, 0x60, 0x00, 0x00, 0x03, 0x02, 0x58, 0x30, 0x00, 0x00, 0x03, 0x02, 0x58, 0x10, 0x00, 0x00, 0x02, 0x02, 0x58, 0x18, 0x00, 0x00, 0x03, 0x06, 0x4C, 0x18, 0x00, 0x00, 0x07, 0x04, 0x44, 0x18, 0x00, 0x00, 0x0D, 0x80, 0x40, 0x3C, 0x00, 0x00, 0x09, 0xC0, 0x40, 0xE6, 0x00, 0x00, 0x18, 0x78, 0x47, 0xC2, 0x00, 0x00, 0x18, 0x0C, 0x4E, 0x02, 0x00, 0x00, 0x1F, 0x86, 0x4C, 0x7E, 0x00, 0x00, 0x0E, 0xC6, 0xE8, 0xEE, 0x00, 0x00, 0x18, 0x43, 0xF8, 0x82, 0x00, 0x00, 0x10, 0x06, 0x4C, 0x03, 0x00, 0x00, 0x30, 0x0C, 0x46, 0x01, 0x00, 0x00, 0x30, 0x18, 0x46, 0x01, 0x00, 0x00, 0x10, 0x18, 0x43, 0x03, 0x00, 0x00, 0x18, 0x10, 0x43, 0x03, 0x00, 0x00, 0x1C, 0x70, 0x41, 0x86, 0x00, 0x00, 0x0F, 0xE0, 0x40, 0xFE, 0x00, 0x00, 0x09, 0x1E, 0x4F, 0x06, 0x00, 0x00, 0x08, 0x30, 0x43, 0x86, 0x00, 0x00, 0x0C, 0x20, 0x41, 0x86, 0x00, 0x00, 0x06, 0x60, 0x40, 0x8C, 0x00, 0x00, 0x07, 0x60, 0x40, 0xB8, 0x00, 0x00, 0x01, 0xE0, 0x41, 0xF0, 0x00, 0x00, 0x00, 0x38, 0xE3, 0x00, 0x00, 0x00, 0x00, 0x0F, 0xBE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F, 0xCF, 0x82, 0x0C, 0x86, 0x46, 0x1F, 0xEF, 0xC3, 0x0C, 0xC6, 0xEE, 0x1C, 0xEC, 0xC7, 0x0C, 0xE6, 0x7C, 0x1C, 0xED, 0x8D, 0x8C, 0xFE, 0x38, 0x1C, 0xED, 0x8D, 0xCC, 0xDE, 0x38, 0x1D, 0xCD, 0xDF, 0xCC, 0xCE, 0x38, 0x1F, 0x8C, 0xF8, 0xEC, 0xC6, 0x38, 0x1F, 0xEC, 0x08, 0x0C, 0xC2, 0x18, 0x1C, 0xEC, 0x00, 0xC0, 0x00, 0x00, 0x1C, 0xFD, 0xFB, 0xC0, 0x00, 0x00, 0x1C, 0xFC, 0x63, 0x00, 0x00, 0x00, 0x1C, 0xEC, 0x63, 0xC0, 0x00, 0x00, 0x1F, 0xEC, 0x60, 0xC0, 0x00, 0x00, 0x1F, 0xCC, 0x63, 0xC0, 0x00, 0x00, 0x1F, 0x0C, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x28, 0x2B, 0x4F, 0x67, 0x42, 0x38, 0x7B, 0xEA, 0x86, 0xB2, 0x28, 0xC7,

};*/

void draw() {

// u8g.drawBitmapP( 37, 0, 6, 50, brainy_bitmap);  // put bitmap
 u8g.setFont(u8g_font_profont11);  // select font
 u8g.drawStr(0, 10, "T: ");  // put string of display at position X, Y
 u8g.drawStr(0, 20, "H: ");
 u8g.setPrintPos(15, 10);  // set position
 u8g.print((int) temperature);  // display temperature from DHT11
 u8g.drawStr(30, 10, "c ");
 u8g.setPrintPos(15, 20);
 u8g.print((int) humidity);  // display humidity from DHT11
 u8g.drawStr(30, 20, "% ");
  
  u8g.drawStr(0, 30, "L: "); 
  u8g.setPrintPos(15, 30);
  u8g.print((String) Lumiere);
  
  u8g.drawStr(0, 40, "L: "); 
  u8g.setPrintPos(15, 40);
  u8g.print((String) photocellReading);
  

}

void setup(void) {

 byte BROCHE_CAPTEUR=A1;
 /* Initialisation du port série */
 Serial.begin(115200);
 Serial.println(F("Demo DHT11 et DHT22"));
 //float temperature, humidity;
 
 /* Place la broche du capteur en entrée avec pull-up */
 pinMode(BROCHE_CAPTEUR, INPUT_PULLUP);
 analogWrite(backlight_pin, 50);  /* Set the Backlight intensity */

}

void loop(void) {

 mesurerTemperatureHumidite();
 mesurerLumiere();
 
 // picture loop
 //appel de foncton
 u8g.firstPage();  
 do {
   //draw(temperature, humidity);
   draw();
 } while( u8g.nextPage() );
 
 /* Pas plus d'une mesure par seconde */
 // N.B. Avec le DHT22 il est possible de réaliser deux mesures par seconde
 delay(1000);

}

/** ######################### Fonction qui mesure la reponse du capteur de lumiere. ############### */

void mesurerLumiere(void) {

 photocellReading = analogRead(photocellPin);
 Serial.print("Analog reading = ");
 Serial.print(photocellReading); // the raw analog reading
 // We'll have a few threshholds, qualitatively determined
 if (photocellReading < 10) {
   Serial.println(" - Noir"); Lumiere= "Noir";
 } else if (photocellReading < 200) {
   Serial.println(" - Sombre"); Lumiere= "Sombre";
 } else if (photocellReading < 500) {
   Serial.println(" - Lumiere"); Lumiere= "lumiere";
 } else if (photocellReading < 800) {
   Serial.println(" - Lumineux"); Lumiere= "lumineux";
 } else {
   Serial.println(" - Tres lumineux"); Lumiere= "tres lumineux";
 }
 //delay(500);

}

//**##############fonction qui mesure la réponse du capteur de la température et de l'humidité ######### void mesurerTemperatureHumidite() {

 /* Lecture de la température et de l'humidité, avec gestion des erreurs */
 // N.B. Remplacer readDHT11 par readDHT22 en fonction du capteur utilisé !
 switch (readDHT11(BROCHE_CAPTEUR, &temperature, &humidity)) {
 case DHT_SUCCESS: 
    
   /* Affichage de la température et du taux d'humidité */
   Serial.print(F("Humidite (%): "));
   Serial.println(humidity, 2);
   Serial.print(F("Temperature (^C): "));
   Serial.println(temperature, 2);
   break;

 case DHT_TIMEOUT_ERROR: 
   Serial.println(F("Pas de reponse !")); 
   break;

 case DHT_CHECKSUM_ERROR: 
   Serial.println(F("Pb de communication !")); 
   break;
 }
 
 /* Pas plus d'une mesure par seconde */
 // N.B. Avec le DHT22 il est possible de réaliser deux mesures par seconde
 //delay(1000);

}


/**

* Lit la température et le taux d'humidité mesuré par un capteur DHT11.
*
* @param pin Broche sur laquelle est câblée le capteur.
* @param temperature Pointeur vers la variable stockant la température.
* @param humidity Pointeur vers la variable stockant le taux d'humidité.
* @return DHT_SUCCESS si aucune erreur, DHT_TIMEOUT_ERROR en cas de timeout, ou DHT_CHECKSUM_ERROR en cas d'erreur de checksum.
*/

byte readDHT11(byte pin, float* temperature, float* humidity) {

 /* Lit le capteur */
 byte data[5];
 byte ret = readDHTxx(pin, data, 18, 1000);
 
 /* Détecte et retourne les erreurs de communication */
 if (ret != DHT_SUCCESS) 
   return ret;
   
 /* Calcul la vraie valeur de la température et de l'humidité */
 *humidity = data[0];
 *temperature = data[2];
 /* Ok */
 return DHT_SUCCESS;

}

/**

* Lit la température et le taux d'humidité mesuré par un capteur DHT22.
*
* @param pin Broche sur laquelle est câblée le capteur.
* @param temperature Pointeur vers la variable stockant la température.
* @param humidity Pointeur vers la variable stockant le taux d'humidité.
* @return DHT_SUCCESS si aucune erreur, DHT_TIMEOUT_ERROR en cas de timeout, ou DHT_CHECKSUM_ERROR en cas d'erreur de checksum.
*/

byte readDHT22(byte pin, float* temperature, float* humidity) {

 /* Lit le capteur */
 byte data[5];
 byte ret = readDHTxx(pin, data, 1, 1000);
 
 /* Détecte et retourne les erreurs de communication */
 if (ret != DHT_SUCCESS) 
   return ret;
   
 /* Calcul la vraie valeur de la température et de l'humidité */
 int fh = data[0];
 fh *= 256.0;
 fh += data[1];
 //fh *= 0.1;
 *humidity = (float) fh * 0.1;

 int ft = data[2] & 0x7f;
 ft *= 256;
 ft += data[3];
 ft *= 0.1;
 if (data[2] & 0x80) {
   ft *= -1;
 }
 *temperature = (float) ft;
 /* Ok */
 return DHT_SUCCESS;

}

/**

* Fonction bas niveau permettant de lire la température et le taux d'humidité (en valeurs brutes) mesuré par un capteur DHTxx.
*/

byte readDHTxx(byte pin, byte* data, unsigned long start_time, unsigned long timeout) {

 data[0] = data[1] = data[2] = data[3] = data[4] = 0;
 // start_time est en millisecondes
 // timeout est en microsecondes

 /* Conversion du numéro de broche Arduino en ports / masque binaire "bas niveau" */
 uint8_t bit = digitalPinToBitMask(pin);
 uint8_t port = digitalPinToPort(pin);
 volatile uint8_t *ddr = portModeRegister(port);   // Registre MODE (INPUT / OUTPUT)
 volatile uint8_t *out = portOutputRegister(port); // Registre OUT (écriture)
 volatile uint8_t *in = portInputRegister(port);   // Registre IN (lecture)
 
 /* Conversion du temps de timeout en nombre de cycles processeur */
 unsigned long max_cycles = microsecondsToClockCycles(timeout);

 /* Evite les problèmes de pull-up */
 *out |= bit;  // PULLUP
 *ddr &= ~bit; // INPUT
 delay(100);   // Laisse le temps à la résistance de pullup de mettre la ligne de données à HIGH

 /* Réveil du capteur */
 *ddr |= bit;  // OUTPUT
 *out &= ~bit; // LOW
 delay(start_time); // Temps d'attente à LOW causant le réveil du capteur
 // N.B. Il est impossible d'utilise delayMicroseconds() ici car un délai
 // de plus de 16 millisecondes ne donne pas un timing assez précis.
 
 /* Portion de code critique - pas d'interruptions possibles */
 noInterrupts();
 
 /* Passage en écoute */
 *out |= bit;  // PULLUP
 delayMicroseconds(40);
 *ddr &= ~bit; // INPUT

 /* Attente de la réponse du capteur */
 timeout = 0;
 while(!(*in & bit)) { /* Attente d'un état LOW */
   if (++timeout == max_cycles) {
       interrupts();
       return DHT_TIMEOUT_ERROR;
     }
 }
   
 timeout = 0;
 while(*in & bit) { /* Attente d'un état HIGH */
   if (++timeout == max_cycles) {
       interrupts();
       return DHT_TIMEOUT_ERROR;
     }
 }
 /* Lecture des données du capteur (40 bits) */
 for (byte i = 0; i < 40; ++i) {

   /* Attente d'un état LOW */
   unsigned long cycles_low = 0;
   while(!(*in & bit)) {
     if (++cycles_low == max_cycles) {
       interrupts();
       return DHT_TIMEOUT_ERROR;
     }
   }
   /* Attente d'un état HIGH */
   unsigned long cycles_high = 0;
   while(*in & bit) {
     if (++cycles_high == max_cycles) {
       interrupts();
       return DHT_TIMEOUT_ERROR;
     }
   }
   
   /* Si le temps haut est supérieur au temps bas c'est un "1", sinon c'est un "0" */
   data[i / 8] <<= 1;
   if (cycles_high > cycles_low) {
     data[i / 8] |= 1;
   }
 }
 
 /* Fin de la portion de code critique */
 interrupts();

 /*
  * Format des données :
  * [1, 0] = humidité en %
  * [3, 2] = température en degrés Celsius
  * [4] = checksum (humidité + température)
  */
  
 /* Vérifie la checksum */
 byte checksum = (data[0] + data[1] + data[2] + data[3]) & 0xff;
 if (data[4] != checksum)
   return DHT_CHECKSUM_ERROR; /* Erreur de checksum */
 else
   return DHT_SUCCESS; /* Pas d'erreur */
 //delay(5000);  // Delay of 5sec before accessing DHT11 (min - 2sec)

}