Gruino : DIY – Voir si la lumière est bien allumée avec une photorésistance et Arduino

Bonjour à  tous,

Nous savons désormais communiquer avec la carte Arduino et récupérer les informations de température et d’humidité relevés par le capteur DHT22 connecté à  un module. En gros nous savons faire le plus important. Le plus important certes mais cela ne fait pas tout, nous allons voir dans cet article comment contrôler si la lampe de la box est bien allumée. Cela constitue un premier pas vers un système de commande de cette dernière.

Capteur utilisé :

Pour contrôler que la lampe est bien allumée de manière fiable et sans risque j’ai choisi d’utiliser une photo résistance : 183598_LB_00_FB.EPS_1000

Ce type de capteur est une résistance dont la valeur varie en fonction de la quantité de lumière reçu. Il existe des tas de petits montages sur internet à  faire sois même ou des modules tout fait pour coder la valeur de la résistance sous forme binaire ou pour la récupérer de manière analogique. Pour ma part, je n’avais pas envie de m’embêter, j’ai pris un montage sur Arobose qui s’appelle « Module TinkerKit LDR: capteur de lumière » à  8,97€ avec une autre commande que j’ai passé en même temps.

Fonctionnement :

Le fonctionnement est extrêmement simple, On alimente le capteur qui renvoie une tension variable en fonction de la lumière qu’il reçoit. Il suffit alors de connecter le retour sur une entrée analogique de la carte Arduino et de lire la valeur qu’il reçoit.

Programmation :

/*****************************************************************
Détermine si la lumière est allumée ou éteinte. 
La réponse est binaire, cela peut permettre une réponse rapide 
en cas de manque de place dans le flux de données.
*****************************************************************/
int isLightOn(int port)
{
   int valeurLumiere=0;
   valeurLumiere = analogRead(port);
   if(valeurLumiere>500)
   {
         return 1; 
   }
   else
   {
         return 0; 
   }
}

/*****************************************************************
renvoie une quantité de lumière mesurée par la diode. 
Les valeurs vont de 0 à  1023 en fonction de la quantité de lumière
reçu.
*****************************************************************/
int LightLevel(int port)
{
   int valeurLumiere=0;
   valeurLumiere = analogRead(port);
   return valeurLumiere;
}

Vous pourrez remarquer que j’ai réaliser deux fonctions. C’est un peu du luxe car je n’en utilise qu’une seul pour le moment. Mais quand j’étais parti à  coder je me suis dit que ça ne coutais pas plus chère de faire la deuxième des maintenant et que ça serai peut être utile à  quelqu’un.

Pour lire la fameuse valeur reçu on utiliser la fonction « analogRead(port) » ou port est le numéro du port que l’on veut lire (celui ou est branché le retour du capteur). Cette fonction renvoie une valeur comprise entre 0 et 1023.

La première fonction renvoie simplement 1 si la lumière détecté dépasse un certain seuil et 0 si celle ci est inférieur à  ce même seuil. Ce qui en gros correspond à  : « La lumière est allumée ? oui ou non ». Vous pourrez modifier le seuil si besoin.

La seconde fonction permet quand à  elle de renvoyer cette fameuse valeur lue. C’est celle ci que j’utilise car sur mon pc je stock dans une petite base de donnée l’intégralité des relevés effectué toutes les 5mn (température / humidité / lumière). Ce qui me permet de faire des petits graphiques.

Voici la version complète du programme correspondant à  mon utilisation. Celui ci tourne depuis quelques mois déjà  et fonctionne plutôt bien. J’ai eu quelques coupures avec la liaison radio (1h par ci 1h par la) que je n’ai pas cherché à  résoudre et qui ne reviennent plus depuis un moment. Libre à  vous de l’utiliser 😉

#include <DHT.h>

#define DHTPIN 2 // what pin we're connected to
#define DHTTYPE DHT22 // DHT 22 (AM2302)

DHT dht(DHTPIN, DHTTYPE);

float Temperature();
float Humidite();
void lire();
int LightLevel(int port);
int isLightOn(int port);

  
void setup()
{
   pinMode(13, OUTPUT);
   digitalWrite(13, LOW);
     
   Serial.begin(9600);
   dht.begin();
}
   
void loop()
{
  lire();
}

void lire()
{
   if(Serial.available() > 0)
   {
       switch(Serial.read())
       {
           case 'e':
               digitalWrite(13, LOW);
               break;
                 
           case 'm':
               digitalWrite(13, HIGH);
               break;
           case 't':
               float t;
               t = Temperature();
               if(t != -99)
               {
                     Serial.println(t); 
               }
               else
               {
                   Serial.println("erreur de lecture du DHT");
               }
               break;
           case 'h':
               float h;
               h = Humidite();
               if(t != -99)
               {
                     Serial.println(h); 
               }
               else
               {
                   Serial.println("erreur de lecture du DHT");
               }
               break;
           case 'l':
               int l;
               l = LightLevel(0);
               Serial.println(l);
               break;

       }
   }
}

/*****************************************************************
Détermine si la lumière est allumée ou éteinte. 
La réponse est binaire, cela peut permettre une réponse rapide 
en cas de manque de place dans le flux de données.
*****************************************************************/
int isLightOn(int port)
{
   int valeurLumiere=0;
   valeurLumiere = analogRead(port);
   if(valeurLumiere>500)
   {
         return 1; 
   }
   else
   {
         return 0; 
   }
}

/*****************************************************************
renvoie une quantité de lumière mesurée par la diode. 
Les valeurs vont de 0 à  1023 en fonction de la quantité de lumière
reçu.
*****************************************************************/
int LightLevel(int port)
{
   int valeurLumiere=0;
   valeurLumiere = analogRead(port);
   return valeurLumiere;
}

float Temperature()
{
   float t = dht.readTemperature();

   // check if returns are valid, if they are NaN (not a number) then something went wrong!
   if (isnan(t)) 
   {
       //Serial.println("Failed to read from DHT");
       return -99;
   } 
   else 
   {
       //Serial.print(t);
       return t;
   }
}

float Humidite()
{
   float h = dht.readHumidity();

   if (isnan(h)) 
   {
       //Serial.println("Failed to read from DHT");
       return -99;
   } 
   else {
       //Serial.print(h);
       return h;
   }
}

Voila.

J’espère que ce petit projet en inspirera certains. Dans un prochain article j’ajouterai la gestion de la ventilation, j’ai fais quelques tests hier mais j’attends de déménager pour ajouter cela à  mon montage actuel pour éviter de tout sortir pour rien car il faut ajouter un module.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *