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

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

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

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ériel utilisé :

- Capteurs température et humidité CYTX DHT11

- Résistance de 10 KOhm

- écran LCD 84x48 nokia 5110 module avec rétroéclairage bleu et adaptateur PBC

- Résistance de 1 KOhm

- Capteur de lumière : photorésistance

- Sonde PH : 1 Set Liquide PH 0-14 + 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 Longue2017, un grand merci à toutes et tous.

Pour le capteur de température et d'humidité DHT11 :

voici les références :

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 associant CapteurLUX, capteur DHT11 et écran LCD :

//** inclure une librairie pour l'ecranLCD nokia 5110 (chinois)
#include "U8glib.h"
//#include "dht.h" (pas réussi à l'installer)

//#define dht_apin A1
#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)
}

Pour le circuit avec la sonde PH

File:circuit-PHmetre.pdf

voici les références :

les plus intéressantes :

en anglais : http://scidle.com/how-to-use-a-ph-sensor-with-arduino/

en français  : https://matdomotique.wordpress.com/2017/07/17/utilisation-dun-module-chinois-de-mesure-de-ph/

https://forum.arduino.cc/index.php?topic=390751.0

voici le code

const int analogInPin = A0; 
int sensorValue = 0; 
unsigned long int avgValue; 
float b;
int buf[10],temp;
void setup() {
Serial.begin(9600);
}

void loop() {
for(int i=0;i<10;i++) 
{ 
 buf[i]=analogRead(analogInPin);
 Serial.print(buf[i]);
 Serial.print('\n');
 delay(10);
}
for(int i=0;i<9;i++)
{
 for(int j=i+1;j<10;j++)
 {
  if(buf[i]>buf[j])
  {
   temp=buf[i];
   buf[i]=buf[j];
   buf[j]=temp;
  }
 }
}
avgValue=0;
for(int i=2;i<8;i++)
avgValue+=buf[i];
float pHVol=(float)avgValue*5.0/1024/6;
float phValue = -5.70 * pHVol + 21.34;
Serial.print("sensor = ");
Serial.println(phValue);

delay(20);
}