====== Capteurs humidité température lumière pH sur une carte Arduino ======
===== 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
===== 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)
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.
{{ media_05:capt-dht11-photocell-lcdnokia5110_bb.jpg?direct |}}
===== 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/|utiliser un capteur de temperature et d humidite 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''' ======
voici les références :
* {{ media_05:circuit-phmetre.pdf | Circuit Ph Metre}}
* 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);
}
{{tag>capteurs}}