Arduino : Réception de nouveaux jouets et avancement de gruino

Salut à  tous,

Cette semaine j’ai reçu de nouveaux jouets pour faire des expérimentations avec Arduino :

  • Deux lecteurs de carte micro SD
  • Trois Capteurs de présences Infrarouges passifs (PIR)
  • Un gyroscope
  • Une Caméra
  • Un capteur à  effet Hall

unnamed

Le projet Gruino va donc pouvoir avancer un peu grâce au lecteur de carte micro SD qui va permettre d’enregistrer les données sur la carte micro SD et donc de rendre le montage indépendant du PC. Il est plus facile de maintenir l’alimentation d’une Carte Arduino que d’un PC lors de coupures de courant et il est intéressent de voir le comportement de l’environnement des plantes en cas de coupures. Le second me servira à  faire des expérimentation et me permettra de l’avoir sous la main sans avoir à  le piquer à  mon prototype gruino actuel.

Les capteurs PIR vont me servir à  domotiser mes éclairages et donnerons lieux à  un nouveau projet dans les mois à  venir qui consistera à  domotiser une partie de la maison pour mieux gérer la consommation d’énergies, faire des stats, gagner en confort et pourquoi pas en sécurité.

Les capteurs A effet hall serviront également pour le projet domotique mais aussi pour un autre projet (et oui encore un) qui consistera à  mettre un peu d’électronique embarqué dans mon vélotaf, le tout alimenter par une dynamo de moyeu. Ce capteur servira alors pour indiquer la vitesse réelle du vélo (plus précis qu’un GPS).

Le gyroscope c’était plus pour le délir et quelques tests, il pourra éventuellement servir pour un bras mécanique ou un drone.

La caméra coutait 7€ donc je l’ai prise en passant pour voir ce que ça donnait mais c’est un peu trop compliqué pour moi pour le moment. Je verrai peut être pour l’ajouter pour faire des photos des boxes à  intervalles réguliers.

Pour ce qui est de l’avancement de gruino :

 le projet à  un peu ralenti car avec les beaux jours j’ai pleins de truc à  faire et je cours un peu partout. Le prototype tourne toujours sans souci. Suite aux évolutions dont j’ai parlé ci-dessus je pense me lancer dans un premier prototype « réel » en développant ainsi ma propre carte.   Cette décision n’est pas simple, car une fois la carte conçu il sera plus compliqué de la faire évoluer. J’hésite donc à  attendre et ajouter de nouveaux capteurs (vent / pression / PH / EC / etc.) ou à  partir sur une première version kit à  la faire évoluer ultérieurement.

Cette première version me servirai dans mes trois espaces de cultures ce qui me serait bien utile   ! Il faut aussi que je développe une vrai interface web pour gérer plus facilement tout ça et pour l’arrivée des future capteurs dans la maison de manière à  tout centraliser. Il est aussi prévu de remplacer le pc qui fait les relevés par une carte Raspberry pi dédiée 🙂

voila voila 🙂 à  bientôt

Gruino : Piloter un Relai

Attention : Les relais présentés ici sont commandés en 5V mais peuvent piloter des appareils 220V. Cette tension est dangereuse et peut s’avérer mortel. Quand vous branchez vos fils faite le toujours hors courant soit en débranchant la prise soit en coupant le disjoncteur. Renseignez vous sur les règles de sécurité concerné lorsque l’on touche à  du 220V. Je ne peux pas être tenu responsable d’un éventuel accident domestique suite à  la lecture de cet article.

Salut à  tous,

Aujourd’hui un article plus simple que les précédents mais qui, avec tout ce que nous avons vu avant, permet de faire des trucs sympa 🙂

En effet nous allons voir aujourd’hui comment piloter un Relai avec notre carte Arduino. Pour cela c’est très simple, il vous faudra une platine avec des relai, une carte Arduino, et comme d’habitude des fils 🙂

La carte ressemble à  ça :

 La carte Relai je l’ai personnellement acheté sur le site miniinthebox qui est pour moi une vrai mine d’or et pas chère en plus ! Pour ma part j’ai pris une carte pouvant gérer 2 relais car dans l’un de mes espaces j’ai deux lampes. Les relais de ma carte supporte du 220v et jusqu’à  10A soit 2200W. Attention quand vous choisirez la votre à  bien prendre des relais pilotable en 5v sinon ce qui suit ne fonctionnera pas.

Un relai c’est en gros un interrupteur. Il peut être « normalement fermé », dans ce cas le courant passe et donc il faut activer le relai pour éteindre ce qui est branché dessus par exemple. Il peut aussi être « normalement ouvert », dans ce cas il faut activer le relai pour allumer ce qui est branché dessus, ce qui me parait plus logique à  moi.

Sur ma carte je peux choisir le « mode » simplement dans la manière de brancher la charge (lampe ou autre). Il y à  une patte au milieu pour « l’arrivée du courrant », une patte à  droite pour se brancher en mode « normalement fermé » et une patte à  gauche pour se brancher en « normalement ouvert« . C’est d’ailleurs ce qu’indique le petit symbole sur la carte :

Branchement sur la carte Arduino :

Il faut alimenter la carte en 5V et lui fournir une masse (les fils rouge et noir sur la photo ci-dessous).

Ensuite il faut deux fils (un par relai) que l’on branche sur deux sorties de notre Arduino (fils orange et marrons sur la photo ci dessous).

Programme :

Cette fois ci c’est tellement simple qu’il n’y a rien à  inclure… Tout est fourni par Arduino directement.

Nous allons pour des raisons de lisibilité définir les ports des relais dans des constantes :

#define RELAY_1_PIN 7   // pin connecté au Relai 1 
#define RELAY_2_PIN 8   // pin connecté au Relai 2

Dans la fonction « setup() » nous initialisons les ports des relais :

   pinMode(RELAY_2_PIN,OUTPUT);
   pinMode(RELAY_1_PIN,OUTPUT);
   digitalWrite(RELAY_1_PIN,LOW);
   digitalWrite(RELAY_2_PIN,LOW);

Pour les activer il vous suffit d’écrire dans votre fonction :

digitalWrite(RELAY_1_PIN,HIGH);
digitalWrite(RELAY_2_PIN,HIGH);

Vous entendrez un « tic » signifiant que la lame du relai a bien bougé. Si vous branchez une charge dessus vous verrez alors son état changer 🙂

Et pour les désactiver :

digitalWrite(RELAY_1_PIN,LOW);
digitalWrite(RELAY_2_PIN,LOW);

Voila amusez vous bien !

Très bientôt un article qui cumule l’horloge RTC et la carte relai pour faire un programmateur !

Gruino : Ajout d’une horloge RTC

Salut à  tous,

Aujourd’hui je vais vous expliquer comment apprendre maintenant à  votre carte Arduino à  connaître l’heure et la date ! Ce qui peut s’avérer très pratique pour faire un minuteur ou une action à  des heures régulières.Pour cela nous allons utiliser un petit montage appelé horloge RTC pour Real Time Clock ou pour les non anglophones Horloge Temps Réel. Ces petits montages munis d’une pile sont autonome et fournisse l’heure de manière relativement précise.

Vous allez me dire oui mais pourquoi ne pas directement demander à  Arduino de   compter les secondes pour savoir se situer dans le temps ?

Tout simplement car en cas de coupure de courant Arduino sera perdu et recommencera à  Zero. Tandis qu’avec ce petit montage Arduino n’aura qu’a demandé l’heure comme à  son habitude au module et saura ainsi la date et l’heure.

Pour mon projet Gruino j’ai décidé d’utiliser une horloge basé sur un composant DS1307. La platine toute prête coute entre 3 et 7€ environ et est fourni ou non avec sa pile de sauvegarde. Il est tout petit (à  peu près la taille d’une pièce de 1€) et très simple à  utiliser.

Vola la bête :

Vous remarquerez les 4 fils qui « sorte » du module, j’ai du les souder moi même car sur le module que j’ai commandé il n’y avait pas de barrette pour enficher les fils sans soudure. Vous l’aurez compris il n’y a donc besoin que de 4 fils :

+5V
La masse
SDA
SCL

Pour le branchement c’est simple :

Le 5v et la masse pour alimenter le module

Le SCL et SDA respectivement sur les broches A5 et A4 de votre Arduino pour la communication avec l’horloge via le protocole I2C. I2C est un protocole série qui m’est encore inconnue, j’ai donc utilisé une librairie toute faite pour interroger l’horloge que nous verrons plus loin.

La programmation :

Pour ce qui est du code c’est très simple aussi, grâce à  une librairie encore fourni par le site Adafruit qui fonctionne très bien et qui est plutôt intuitive. Cette librairie appelée RTCLib est téléchargeable ici : https://github.com/adafruit/RTClib

Pour commencer on va inclure deux bibliothèque, la RTCLib et wire (incluse avec le logiciel Arduino) :

#include <Wire.h>
#include "RTClib.h"

Ensuite on va ajouter les divers initialisation juste en dessous :

RTC_DS1307 rtc;

Dans la fonction setup() on va mettre les instruction suivante pour démarrer le module RTC :

#ifdef AVR
   Wire.begin();
#else
   Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
   rtc.begin();

Puis, toujours dans la fonction setup() on va ajouter la condition suivante qui permet d’initialiser l’heure au premier démarrage du module :

   if (! rtc.isrunning()) {
       rtc.adjust(DateTime(__DATE__, __TIME__));
   }

Le souci avec la ligne rtc.adjust(DateTime(__DATE__, __TIME__)); c’est qu’elle prends les variable DATE et TIME du pc au moment de la compilation, donc pour que l’heure soit réglée au plus juste il vous faudra cliquer sur téléverser pour ne pas prendre de retard.

Si vous avez un souci d’heure il vous suffit de forcer cette fonction. Pour ma part quand ça m’est arrivé pendant les premiers tests j’ai juste déplacé la fonction dans le setup pour forcer le programme à  passer dessus. Je l’ai ensuite supprimé pour ne pas avoir de problèmes lors des auto reset de la carte quand on se connecte via la liaison série 🙂

Pour lire l’heure maintenant :

Il vous suffira d’appeler dans votre fonction le code suivant :

DateTime now = rtc.now();
 Serial.print(now.hour());
 Serial.print(':');
 Serial.print(now.minute());
 Serial.print(':');
 Serial.print(now.second());
 Serial.println();

Pour lire l’heure et la renvoyer au format hh:mm:ss via la liaison série. Bien sur si vous voulez récupérer les info par la liaison série n’oubliez pas d’initialiser celle ci comme nous l’avons vu ici par exemple.

Voici maintenant le code complet du projet mis à  jour avec l’ajout de l’interrogation de l’heure par la liaison série justement :

#include <DHT.h>
#include <Wire.h>
#include "RTClib.h"

#define DHTPIN 2             // pin connecté au DHT
#define DHTTYPE DHT22   // DHT 22 (AM2302)
#define LED_PIN 13         // pin connecté à  la led de test

DHT dht(DHTPIN, DHTTYPE);
RTC_DS1307 rtc;

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

int plage_lampes[7][4];

void setup()
{
   pinMode(LED_PIN, OUTPUT);
   digitalWrite(LED_PIN, LOW);
   digitalWrite(RELAY_1_PIN,LOW);
   digitalWrite(RELAY_2_PIN,LOW);

#ifdef AVR
   Wire.begin();
#else
   Wire1.begin(); // Shield I2C pins connect to alt I2C bus on Arduino Due
#endif
   rtc.begin();

   Serial.begin(9600);
   dht.begin();

   if (! rtc.isrunning()) {
       Serial.println("RTC is NOT running!");
       rtc.adjust(DateTime(__DATE__, __TIME__));
   }

}

void loop()
{
  lire();
}

void lire()
{
   if(Serial.available() > 0)
   {
       switch(Serial.read())
       {
           case 'e':
               digitalWrite(LED_PIN, LOW);
               break;

           case 'm':
               digitalWrite(LED_PIN, 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;
           case 'r':
               DateTime now = rtc.now();
               Serial.print(now.hour());
               Serial.print(':');
               Serial.print(now.minute());
               Serial.print(':');
               Serial.print(now.second());
               Serial.println();
               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;
}

void DHTt()
{
   float h = dht.readHumidity();
   float t = dht.readTemperature();

   if (isnan(t) || isnan(h)) {
       Serial.println("Failed to read from DHT");
   } else {
       Serial.print("Humidity: ");
       Serial.print(h);
       Serial.print(" %t");
       Serial.print("Temperature: ");
       Serial.print(t);
       Serial.println(" *C"); 
   }
}

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

   if (isnan(t)) 
   {
       return -99;
   } 
   else 
   {
       //Serial.print(t);
       return t;
   }
}

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

   if (isnan(h)) 
   {
       return -99;
   } 
   else {
       return h;
   }

Voila, en espérant avoir été claire et avoir pu vous aider à  appréhender ces petites horloges fort pratique. A venir très bientôt un tuto pour piloter un Relai et faire un programmateur pour les lampes avec celui-ci couplé à  l’horloge DS1307 que nous venons de voir !

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 : 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.

Gruino : DIY – Relever la température et l’humidité avec Arduino et DHT22

Bonjour à  tous,

Maintenant que nous avons vu dans un précédent article comment communiquer avec la carte Arduino il serai bien que cette dernière nous servent à  quelque chose et que le projet commence enfin à  prendre forme non ? !

C’est justement l’objet de cet article. Nous allons voir ici comment demander à  la carte Arduino de réaliser des relevés de températures et d’humidité par le biais d’un capteur DHT22 et d’une librairie récupérée sur internet et réalisée par Adafruit.

unnamed2

Le DHT 22 en place

Les infos techniques sur le DHT22 sont trouvables un peu partout sur internet, la description donnée pas adafruit est visible ici

Connecter le DHT22 à  la carte Arduino :

Le schéma de cablage est disponible également sur le site de Adafruit : visible ici

J’en redessinerai peut être un quand j’aurai du temps libre pour en garder une trace et être sur de ne pas perdre l’information mais de manière générale pleins de sites on repris les schéma de Adafruit et je préfère rendre à  Adafruit ce qui appartient à  Adafruit 🙂

unnamed

Ici on voit le fil bleue (données) aller sur le port 2 de la carte arduino

Télécharger la librairie :

Elle est disponible encore une fois chez Adafruit ici

Téléchargez le fichier .cpp et le .h

Installer la librairie :

Il suffit de copier les deux fichiers téléchargés dans un dossier nommé « DHT » et de placer celui ci dans le répertoire « libraries » qui se trouve dans le répertoire de l’outil de développement Arduino et de relancer l’application.

Un peu de programmation :

Mise en place et initialisation :

Pour utiliser la librairie il faut tout d’abord dire à  notre programme qu’on souhaite l’utiliser. Pour cela on va utiliser le mot clé « include ». Il se place au tout début du programme et se présente comme ceci :

#include <DHT.h>

Ensuite il faut paramétrer la librairie. Cela se fait avec deux constantes et une fonction d’initialisation :

#define DHTPIN 2 
#define DHTTYPE DHT22 

DHT dht(DHTPIN, DHTTYPE);

#define permet de dire au logiciel que le mot clé qui suit sera une constante.

Pour ceux que ça intéresse en C et en C++ le compilateur replace le premier terme par le deuxième. Donc en gros partout ou le compilateur verra « DHTPIN » il remplacera lors de la compilation « DHTPIN » par 2. C’est très pratique, si par exemple vous utilisez DHTPIN un peu partout et que vous souhaitez changer le capteur de port il vous suffit de remplacer 2 par le nouveau port à  un seul endroit et le compilateur se chargera pour vous de mettre la bonne valeur la ou il faut lors de la compilation.

Revenons à  nos moutons :

DHTPIN sert à  définir le port sur lequel le fil de données du capteur sera connecté, ici le port 2.

DHTTYPE sert à  définir le type de capteur car la librairie gère le DHT11 et le DHT22. Il s’agit dans mon cas du DHT22.

DHT dht(DHTPIN, DHTTYPE); sert à  initialiser le capteur.

Lecture de la température et de l’humidité :

Pour garder un minimum de lisibilité nous allons créer des petites fonctions. Cela facilitera également la mise à  jour du programme si besoin 😉

voici les deux fonctions :

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

   if (isnan(t)) 
   {
       return -99;
   } 
   else 
   {
       return t;
   }
}

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

   if (isnan(h)) 
   {
       return -99;
   } 
   else {
       return h;
   }
}

En gros on à  une fonction « Temperature » de type float (qui retourne un nombre à  virgule) et sans paramètres (il n’y à  rien à  lui fournir). Le contenue de celle ci se trouve entre deux accolades.  On définie dans cette fonction une variable « t » de type float (nombre à  virgule) et on lui donne le retour de « dht.ReadTemperature() » qui est une fonction de la librairie de tout à  l’heure qui demande au capteur la température qu’il capte. Voila tout l’intérêt d’utiliser une librairie, ne pas avoir à  programmer sois même l’interrogation du capteur !!

Le principe est le même pour la fonction humidité.

Il est très important pour ne pas être embeter par l’appel des fonction de rajouter leur nom juste sous l’initialisation des constantes. Cela permet de les appeller depuis n’importe ou dans le programme. On rajoute donc ces deux lignes sous l’initialisation des constantes :

float Temperature();
float Humidite();

Appel des fonctions :

Dans la fonction lire() que nous avions écrit dans l’article précédent nous allons simplement ajouter deux cas :

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;

Ainsi quand le module Arduino recevra un t il renverra par la liaison la température. et quand il recevra h il renverra l’humidité perçut par le capteur.

Code complet :

#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();

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;
       }
   }
}
float Temperature()
{
   float t = dht.readTemperature();

   if (isnan(t)) 
   {
       return -99;
   } 
   else 
   {
       return t;
   }
}

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

   if (isnan(h)) 
   {
       return -99;
   } 
   else {
       return h;
   }
}

Voila, j’espère avoir été claire et que tout cela vous aidera dans vos développement.  Si vous avez des questions n’hésitez surtout pas ! 🙂

Gruino : DIY – Communication sans fil entre arduino et votre PC !

Salut à  tous,

J’ai enfin un peu de temps pour rédiger quelque chose sur le projet Gruino, voici donc  un petit article qui va vous détailler comment faire communiquer votre carte Arduino avec votre PC et ce sans fils en utilisant deux modules XBee Pro Série 1. Cela va s’avérer fort pratique pour notre montage Gruino et nous évitera de devoir brancher le pc pour visualiser les mesures ou pire d’avoir des fils qui trainent   partout…

Faire communiquer la carte Arduino et le PC via les modules XBee était une première pour moi. J’avais acheté ces deux modules XBee en me disant que je les testerai mais n’ayant jamais eu besoin de sans fil avant ils étaient resté au placard.

Etape 1 : Configuration des modules Arduino sur le PC

Prérequis :
Une petite carte recevant la XBee et ayant une sortie USB, ça ressemble à  ça avec la XBee dessus :

IMAG0001

Le pc voit cette carte comme un port série, c’est donc simple à  programmer, j’ai utilisé cette interface pour préparer les deux cartes XBee (réglages).

Configuration des modules :
On branche la carte USB / XBee sur le PC puis on regarde quel port série elle utilise et enfin on le paramètre dans son terminal série préféré (Hyper terminal ou putty par exemple sous Windows).

Les paramètres par défaut sont :
– 9600 bits par secondes pour la vitesse
– 8 bits de données,
– Pas de parité,
– 1 bit de stop
– Pas de contrôle de flux

Une fois le terminal ouvert on tape +++ et on attend un « OK » en retour (sans appuyer sur entrer). Si rien ne se passe vérifiez les quelques points suivantes :

  • Essayez encore en attendant environ 10 secondes entre chaque tentative et tapez bien les +++ rapidement.
  • Vérifier que le module est bien alimenté (le petit voyant vert doit clignoter)
  • Vérifiez bien que vous n’avez pas inversé les fils Rx et Tx si c’est un branchement « maison »
  • Vérifiez le paramétrage de votre liaison série. Les valeurs par défaut sont  rappellée juste au dessus.

Ensuite on envoient la commande ATID xxxx ou xxxx est le numéro que l’on souhaite attribuer à  notre réseau. Par exemple ATID 1111 et on valide en appuyant sur « Entrer »

Ensuite on envoient la commande ATMY xxxx ou xxxx est l’adresse que l’on souhaite donner au module. Par exemple ATMY 1000 et on valide en appuyant sur « Entrer »

Ensuite on envoient la commande ATDL xxxx ou xxxx est l’adresse du module que l’on souhaite joindre. Par exemple ATDL 1001  et on valide en appuyant sur « Entrer »

Ensuite on envoient la commande ATWR pour dire au module XBee de sauvegarder les commandes et on valide en appuyant sur « Entrer ».

Ce qui donne par exemple :

Module 1 :
+++
ATID 1111
ATMY1000
ATDL 1001
ATWR

Module 2 :
+++
ATID 1111
ATMY 1001
ATDL 1000
ATWR

Etape 2 : Côté Arduino

Prérequis :

Une petite platine qui régule l’alimentation de la XBee et qui se branche simplement avec 4 fils :

– Un fil +5v
– La mass
– Un fil Tx
– Un fil Rx

Elle ressemble à  ça avec la XBee dessus :

IMAG0002

Branchement :

Bien faire attention à  brancher le Tx et le Rx dans le bon sens sinon ça ne communiquera pas ^^

Pour le paramétrage j’ai choisi de le faire sur le PC pour les deux modules et de prendre l’un des deux pour le mettre sur le montage.

Pour la communication il suffit de faire communiquer la carte Arduin via le port série comme on le ferai normalement via le port USB de la carte ou via sa sortie RS232. C’est totalement transparent !

Les modules XBee ayant été configuré par le PC la carte n’a rien à  initialiser les paramètres sont écrits dans une EPROM et donc sont conservé même si le module est débranché !

Etape 3 : Tester la communication

Pour tester la communication j’ai rédiger un petit programme plus que classique lors des testes de communications de liaison séries entre un PC et une Arduino.

Voici le code :

void setup()
{
   pinMode(13, OUTPUT);
   digitalWrite(13, LOW);

   Serial.begin(9600);
}

void loop()
{
  lire();
}

void lire()
{
   if(Serial.available() > 0)
   {
       switch(Serial.read())
       {
           case 'e':
               digitalWrite(13, LOW);
               break;                 
           case 'm':
               digitalWrite(13, HIGH);
               break;
       }
   }
}

Ce petit programme allume la led embarqué sur le port 13 de la carte lorsqu’il reçoit un « m » sur la liaison série et l’éteint lorsqu’il reçoit un « e ».

J’ai choisi de mettre les « fonctionnalités liés aux différentes lettres dans une fonction « lire » qui reçoit est appelé par la fonction « loop » de manière à  ce que le code soit un peu plus modulable pour les futures évolution de celui-ci.

la fonction « loop » est comme son nom l’indique si bien, une boucle sans fin qui tourne tant que la carte Arduino est allumée. La fonction « setup » est quand à  elle exécuté à  l’allumage de la carte et permet de positionner les paramètres que l’on souhaite au démarrage pour que tout soit bien initialiser.

Il faut préciser que comme vous pouvez vous en douter il n’y a pas de notions d’heure ou de date. La carte est capable de compter des micro secondes mais pas de savoir quelle heure il est. Il est donc impossible de programmer des actions à  heures fixes. En effet si on lui donne l’heure lors de son démarrage et qu’elle s’éteint, il faudra lui re-fournir l’heure pour que tout fonctionne bien… Mais rassurez vous il existe des petits composants appelés RTC (Real Time Clock ou Horloge Temps Réel pour les non anglophones). Ces petits composants permettent de connaitre l’heure avec une précision relativement correcte et ne coutent pas très chère. Ils seront abordé dans un future chapitre.

Etape 4 : Affinage

Régler la puissance d’émission des cartes :

En passant en mode configuration (+++) comme vu ci dessus on peut voir la puissance d’émission paramétré avec la commande ATPL, les valeurs vont de 0 à  4 pour respectivement aller du mini au maxi, voici les valeurs tirés de la doc de digi pour une XBee-Pro Série 1 :

0 : 10 dbm
1 : 12 dbm
2 : 14 dbm
3 : 16 dbm
4 : 18 dbm

Pour ma part les cartes sont réglés au minimum et cela fonctionne plutôt bien 🙂

IMAG0001

Gruino : Lancement du projet

Présentation

Salut à  tous !
Aujourd’hui je vous annonce par cet article l’officialisation d’un projet qui me tiens à  cœur depuis longtemps, le projet « Gruino » pour Green et Arduino. Le but de ce projet est de réaliser un automate de gestion climatique complet. Par gestion climatique j’entends environnementale. L’objectif est donc de gérer les conditions de température, d’humidité et de lumière dans un premier temps. Je souhaite garder pour moi les arrosages car c’est quelque chose que je trouve qu’il est important de faire sois même pour garder une certaine relation avec ses plantes. Un module sera peut être développé ultérieurement pour gérer les arrosages en période de vacances.

La première étape : La définition du besoin et des versions

Les détails techniques seront révélés sur un article dédié, comme toutes les futures version d’ailleurs. Ici c’est juste le besoin qui est exprimé. Cette section va évoluer au fur et à  mesure des versions.

Version 1.0 : Relevés Intérieur
Le besoin premier pour contrôler le climat dans la boxe est de connaitre son environnement. Pour cela il   est nécéssaire de faire des relevés.
Cette version aura donc pour but de faire des relevés de température, d’humidité et de lumière à  l’intérieur de la boxe. Cela permettra de déterminer si la lumière est allumée ou non, combien de temps elle est allumé.  Elle permettra également de connaitre l’évolution de la température et de l’humidité au sein de la boxe. Il faudra bien évidement prévoir un programme pour faire des relevés réguliers et générer des graphiques. Les relevés seront effectués sans fil via une liaison radio.

Version 2.0 : Gestion du climat immédiat
En fonction des valeurs relevés par la carte (Humidité, Température, Lumière) la carte devra décider d’allumer ou non le brumisateur. Entrera également en jeu une horloge temps réel pour que la carte puisse décider d’allumer ou non la lampe. Les plages horraires d’allumage et d’extinction de la lampe seront directement intégrées au programme. La liaison sans fil choisie étant du XBee pro Série 1 pour le moment il est hors de question de transmettre les ordres du pc aux cartes par cette liaison non sure. Les mise à  jour du programme contenant les plages horraires seront faites par le port USB. La carte sera également capable désormais de gérer l’extraction d’aire et la ventilation du brumisateur. Pour le moment les ventilateurs seront toujours à  fond, l’intelligence de gestion de ces derniers viendra dans une version ultérieur.  

Seconde étape : Le prototypage

Le prototypage sera réalisé avec des cartes Arduino et des platines d’essai classique que l’on trouve un peu partout sur le net. Il sera testé en condition réel dans une de mes boxe de culture, la plus difficile à  gérer, celle de mes orangers et frangipaniers qui sont des plantes tropicales. L’utilisation de ce genre de carte est extrêmement pratique pour réaliser des prototypes fonctionnels avec beaucoup d’avantages :

  • Une évolutivité très simple
  • Des modules réutilisables pour de futures expériences

Mais pour un montage  en utilisation réel cela présente des inconvénients :

  • Encombrement important
  • Des fils partout
  • Solution pas super propre qui fait vraiment brouillon
  • Un cout important

Troisième étape : La carte officielle

Le but de faire une carte « officielle » autrement dit en un seul morceau procurera les avantages suivants :

  • Un cout réduit : Les composants coutent moins chère que les modules achetés séparément
  • Une plus grande stabilité : Les fils partout ce n’est jamais top pour la stabilité
  • Un encombrement réduit : Les modules scotchés ou vissés sur une boite avec des fils partout cela prend de la place

et l’inconvénient suivant :

  • Une évolutivité qui peut vite devenir très complexe sauf si l’on refait une carte mais cela peut vite couter chère du coup. D’où l’intérêt de vraiment bien définir le besoin et de faire des tests poussés sur le prototype et de valider la carte officiel qu’un fois que les prototypes répondent à  une grande partie voir à  la totalité des besoins.

Gruino : Présentation rapide de la carte Arduino Uno

Salut à  tous,

Aujourd’hui présentation d’une petite merveille qui permettra au bricoleurs en tout genre de faire pleins de choses pour améliorer les conditions de vies de leur plantes : Relevé de température, d’humidité, contrôle de ventilateur, de lampes, déplacement d’objets, ajout d’une webcam pour prendre des photos, bref tout ce qui vous passera par la tête.

Voila la bête :

Image venant du site officiel (http://arduino.cc/en/Main/arduinoBoardUno)

Ces petites cartes se programment directement sur le port USB. Elles fonctionnent un peu comme un automate industriel ou un mini PC à  qui l’on demande de faire une action sur un port donnée (lire ou écrire). En fonction de ce que l’on met sur le port on peut par exemple lire le résultat d’un capteur ou envoyer (écrire) un ordre à  une carte de contrôle (actionneur). Elles ont aussi la capacité de communiquer par l’intermédiaire d’un port série directement avec un PC, ce qui est super pratique pour récupérer des informations de capteurs par exemple ou pour envoyer un ordre. Elles se programment en langage C via un petit utilitaire fourni par le constructeur.

J’en entends d’ici hurler « oh mon dieu de la programmation ! mais je ne suis pas programmeur moi ! »

Pas de panique ! Arduino est justement fait pour des gens qui n’ont pas forcément l’envie de devenir des gourous du code ! Il existe des dizaines voir centaines de librairies gratuites sur le net qui vous faciliterons la vie il y a des exemples partout, c’est vraiment très pratique. De plus pour ceux qui n’ont pas ou très peu de connaissance en électronique c’est également un super outil car il existe des tonnes de modules tout fait qu’il ne reste plus qu’à  câbler avec des petits fils sans avoir forcément à  souder, à  calculer les composants, etc !

Bien évidement ces cartes ne sont pas conçues pour une utilisation en « production » mais bien pour du prototypage, on s’en rend vite compte quand on commence à  câbler plusieurs cartes ou capteurs dessus, avec les fils partout c’est vite le bazar. Mais ça reste une super solution pour les bidouilleurs comme moi qui n’ont pas de moyens monstrueux.

A terme et ayant les connaissance nécessaire pour le faire je pense tout de même me faire ma propre carte « complète » intégrant tout le nécessaire pour que cela soit plus « propre » mais celle ci sera toujours basé sur le même micro contrôleur. Et oui Arduino est libre, les schéma pour en refaire une sont dispo sur le site du fabriquant 🙂 Cela me permettra de tout relier sans avoir des fils partout !

Pour ceux que ça intéresse :

Caractéristiques détaillés de la carte