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

Culture Indoor : DIY – Extracteurs silencieux Home Made

Présentation :

Dans les précédents articles je vous ai présenté mes boxes de cultues. Comme je vous l’avait dit il y avait des extracteurs de gaines mis directement dans les trous d’extraction des boxes (sans gaines). Ces derniers, extrêmement bruyants (45dB voir plus) et pas super performants tournaient le matin et l’après midi mais étaient sur une prise programmée pour se couper le midi et le soir car trop bruyants.

Voila à  quoi ils ressemblaient :

extracteur

J’ai donc décidé d’opter pour une solution de performance équivalente voir supérieur et bien plus silencieuse en fabriquant des extracteurs d’air moi même avec des ventilateurs de pc. Par rapport aux extracteurs de gaines ils ont le même défaut, c’est à  dire une pression statique pas super terrible…

Petite précision avant de commencer :

L’objectif de cette boite à  terme est de recevoir l’électronique nécessaire pour réguler automatiquement le climat de mes boites (capteur, carte arduino, carte de commande, etc.) Si vous ne comptez pas faire tout ça le fil 5v ne vous servira à  rien (voir plus loin) et la molex non plus, dans ce cas passez directement 2 fils( +12V et 0v ) et branchez y directement le ventilateur. Pour régler sa vitesse si vous avez pris le même modèle que le mien le potentiomètre est fourni et le ventilateur prévu pour être réguler par celui-ci.

Choix des ventilateurs :

J’ai passé pas mal de temps à  en chercher qui justement avec une pression statique potable, un bon débit et un faible niveau de bruit et surtout en 12V pour pouvoir les contrôler plus tard avec une carte Arduino.

J’ai opté pour des silverstone  sst-fm181 :
Dimensions : 180 x 180 mm
Vitesse : 500 – 1300 tr/min
Débit   : 65 – 150 CFM
Pression statique : 2,38 mm H20
Bruit : 17 – 36 dB

Matériel nécessaire :

Les outils :

Un stylo capable d’écrire sur du plastique :

Un Dremel avec un disque de découpe et un foret de 3mm (4mm dans l’idéal mais ça ne passait pas dans le mien) ou quelque chose pour percer et découper du plastique

Un Tournevis

Le nécessaire pour découper du fil et de la gaine sur mesure (mètre, pince coupante et ciseaux)

Le matériel :

Il faut donc, un ou plusieurs ventilateurs :

Une boite en plastique suffisamment grande pour accueillir le ventilateur et la gaine :

Une prise pour le ventilateur et une prise molex femelle (ici fourni avec le ventilateur) :

Spécifique pour le ventilateur ce petit shunt qui permet de le bloquer à  sa vitesse maxi, c’est soit lui soit le potentiomètre fourni avec. Le ventilateur sera contrôlé à  terme par une carte Arduino donc pas besoin du potentiomètre.

2 chaines pour accrocher la boite :

4 crochets en S pour fixer la chaine à  la boite :

4 crochets fermés (je n’ai pas trouvé de crochets ouverts… avec écrous et rondelles :

4 visses de 4cm de long et 4mm de diamètre avec leur rondelles et écrous pour fixer le ventilateur à  la boite :

6 visses de 2cm de long et 4mm de diamètre avec leurs écrous pour fermer le couvercle de la boite :

De la gaine insonorisé (ici 12.5cm de diamètre qui est le standard le plus petit de mes boxes) :

 

6 dominos (2 x 3 ) pour connecter la box à  une alimentation de PC :

Du fil électrique pouvant supporter la puissance de l’installation, personnellement je préfère le souple. J’ai voulu du rouge noire et jaune pour respecter les conventions électriques des pc (Rouge pour le 5V Noir pour la masse et Jaune pour le 12V) :

Du gros scotche étanche pour éviter d’avoir des fils qui se promène et étanchéifier la boite au mieux pour éviter les perte de pressions :

 

Du scotch d’électricien pour pouvoir assembler un minimum les fils, il peut être remplacer par une gaine si vous en avez :

La Conception :

On va commencer par dessiner la forme du ventilateur, pour se faire j’ai placé le ventilateur sur la boite et j’ai fais le tour de l’intérieur avec le stylo :

Une petite découpe au dremel :

La même chose pour la gaine en prenant le diamètre extérieur (ovale car la boite n’était pas tout à  fait assez haute) :

Après la découpe :

Découpe du fil d’alimentation du ventilateur :

Dénudage du fil du ventilateur et de la molex Femelle :

Dominotage de la molex femelle :

Dénudage, stochage et dominotage du cable pour le déport d’alimentation :

On fait un petit trou à  la perceuse que l’on élargie progressivement (environ 1cm) pour passer les fils. Puis on passe le fil de l’intérieur vers l’extérieur pour avoir le domino dans la boite et on scotche pour ne pas que le câble bouge. J’en ai profité pour passer ici Le câble du ventilateur extérieur par le même trou.

J’ai mis ici du scotche pour éviter que l’aire ne sorte par le petit trou :

Branchement des 2 prises de ventilateurs sur les dominos et les ventilateurs suivi d’un coup de scotche pour fixer le tout :

Fixation de la molex femelle sur l’autre bout du câble pour pouvoir le brancher sur une alimentation de PC directement :

Pour bien fixer le couvercle j’ai décider de le visser. J’ai mis une visse par angle et une au milieu de côtés les plus longs de la boite. Ici j’ai mis l’angle dans le vide et la boite a l’envers pour pouvoir percer proprement :

Le trou réalisé et une première visse en place :

Tous les trous sont fait et vissé, on remarque 4 autres trous légèrement à  l’intérieur du couvercle, ce sont les trous qui vont recevoir les crochets fermés :

Les crochets en place :

 

Installation de la gaine :

Étanchéification de la gaine au gros scotche étanche :

Fermeture de la boite et vissage :

Mise en place de la boite dans la grow box :

Et voila, un extracteur potable qui fait vraiment très peu de bruit, réglable en vitesse manuellement si vous avez mis le potentiomètre et automatiquement si vous y ajoutez un peu d’électronique. Il reste juste à  le brancher sur une alimentation de pc ou une alimentation 12V continue standard qui correspond au besoin du ventilateur.

Avantages Inconvénients :

Avantage du montage :
– Prix
– Facile à  piloter avec une Arduino (12v)
– Silence

Inconvénient :
– Ventilateur pas prévu pour donc perte importante de charge (je ne pense pas que l’on puisse atteindre les 250m3/h annoncés, à  moins de mettre plusieurs ventilateurs à  la queue leu leu et dans ce cas le cout augmente.

Culture Indoor : Présentation de la GrowBox Twin L

Aujourd’hui un petit article pour vous présenter ma GrowBox Twin L, il s’agit d’une version à  étages contrairement à  la première box que je vous ai présenté. J’ai acheté cette box avec l’accord de ma gentille chérie extrêmement patiente pour remplacer mes Boxes faites maison qui ne sont pas très esthétiques et prennent pas mal de place. Avec cette GrowBox j’ai commandé une lampe CFL SuperPlant de 250W floraison avec son réflecteur pour un étage, j’ai récupéré les deux lampes CFL de 125W de mes Boxes maison pour l’autre étage.

La GrowBox Twin L est une chambre de culture de marque GrowBox reconnaissable comme sa soeurette à  son logo :

Ses caractéristiques :

Elles est similaire à  l’autre boxe à  quelques petits détails prêt, il va donc y avoir un peu de redite :

– Elle est en toile horticole, noir à  l’extérieur et en Milard Diamond à  l’intérieur pour bien réfléchir la lumière (98% de réflectivité).

– Sa structure tubulaire est solide et peut supporter jusqu’à  environ 100kg.

–     L’ouverture est faite par deux grandes fermetures éclaires solides qui partent en arc de cercle :

Il y a des trous prévus pour des intractions et extractions d’aire actives et des intractions passives sous forme de «  fenêtres grillagés  » avec un petit cache pour éviter que la lumière ne sorte.

Un double fond étanche appelé «  piscine  » est également fourni.

A noté que lors de mon achat il était mis que deux doubles fonds seraient fournis, ce qui ne fut pas le cas. Il s’agissait d’une erreur de saisi d’une personne du site ou je me fournis. Après explication nous avons trouvé un arrangement.

J’ai fabriqué un double fond pour l’étage avec une plaque de contre plaqué et du milard que j’avais en stock, je ferais un article détaillé dessus.

Côté dimensions elle mesure 1m x 1m x 2m divisé en un espace de 1.20m de haut et un de 80cm de haut.

Son prix : 219€ lors de l’achat

Déballage :

Le colis arrivé pèse une bonne vingtaine de kilos.

Tout est bien rangé à  l’intérieur. Il faut prévoir un peu de place pour pouvoir mettre tous les morceaux bien rangés pour faciliter le montage.

La toile à  l’aire bien résistante.

Montage :

Le plan est clair et bien expliqué.

Le montage n’a pas posé de difficulté particulière on a du mettre environ 15mn avec ma chérie. Je pense que par contre pour quelqu’un plus petit (je mesure 1.80m) cela peut se compliqué au moment d’enfiler la toile sur la structure… Donc pour ces personnes prévoyez un ami (grand) ou un tabouret en faisant attention à  ne pas tomber… A noté que la toile est plus difficile à  enfilé que sur la première boxe, cela est lié au fait que celle-ci n’a pas de grande fermeture éclaire centrale.

Nous avons décidés de la mettre à  l’envers pour avoir le grand espace en bas et le petit en haut. Cela n’a pas posé de problème particulier mis à  part que les trous pour l’intraction sont plus nombreux que ceux pour l’extraction, du coup la donne est maintenant inversé… Il faut faire attention au sens dans lequel l’air circule.

Installation de la lampe :

La lampe que j’ai commandé comprend l’ampoule, le réflecteur et 2 fixation rapides appelés «  easy rollers  ». Exactement le même problème que pour la première boxe, Les fixations ne sont pas pratique par rapport au support de la GrowBox. En effet ils sont prévu pour être accrochés à  des crochets or la GrowBox ne présente que des barres trop grosses pour mettre les easy rollers. J’ai donc du passer par une petite étape de bricolage improvisé :

Les lampes de mes anciennes boxes étaient fixés avec des chaines et des crochets, j’ai donc pu les réutiliser.

Remplissage :

La boite mesure 1m² au sol mais étant sur deux étages cela fait 2m² ! J’ai donc vidé un peu la première boite pour éviter que des plantes soient à  l’ombre et j’ai pu y placer presque toutes les plantes de mon appart, l’ensemble de mes aloés verra, mes plantes carnivores, mes cactus, etc !

Premières impressions :

Comme sa grande sœur la qualité est la, la toile semble vraiment solide et le textile horticole de très bonne qualité. Le fait d’avoir un étage est vraiment super pratique, je pense surtout aux amateurs de semi, de cactus et d’orchidées qui ne sont pas forcément super hauts. Cela permet donc de doubler sa surface utile au sol. Par contre attention ça chauffe dur la dedans !

Conclusion :

Je suis vraiment content de cet investissement, ma copine aussi et surtout, mes plantes ! C’est un investissement mais c’est vraiment efficace. Voici quelques photos rapides pour vous faire une idée du montage :

Culture Indoor : Présentation de la GrowBox L

Aujourd’hui un petit article pour vous présenter ma GrowBox L. Je l’ai acheté en février en complément de mes Boxes faites maison trop petites pour sauver tous mes orangers. Ceux-ci manquaient beaucoup de lumière et étaient en train de dépérir dans l’appartement. Avec cette GrowBox j’ai commandé une lampe CFL SuperPlant de 250W floraison avec son réflecteur ainsi que d’autre petites choses que je détaillerai plus tard.

La GrowBox L est une chambre de culture de marque GrowBox reconnaissable à  son logo :
Ses caractéristiques :

Elle est en toile horticole, noir à  l’extérieur et en Milard Diamond à  l’intérieur pour bien réfléchir la lumière (98% de réflectivité).

Sa structure tubulaire est solide et peut supporter jusqu’à  environ 100kg.

L’ouverture est faite par une grande fermeture éclaire centrale sur toute la hauteur plus des fermetures éclaires en haut et en bas qui partent sur les côtés.

Il y a des trous prévus pour des intractions et extractions d’aire actives et des intractions passives sous forme de « fenêtres grillagés » avec un petit cache pour éviter que la lumière ne sorte.

Un double fond étanche appelé « piscine » est également fourni.

Côté dimensions elle mesure 1m x 1m x 2m

Son prix : Autour de 180€ lors de l’achat

Déballage :

Le colis arrivé pèse une bonne vingtaine de kilos.

Tout est bien rangé à  l’intérieur. Il faut prévoir un peu de place pour pouvoir mettre tous les morceaux bien rangés pour faciliter le montage.

La toile à  l’aire bien résistante.

Montage :

Le plan est clair et bien expliqué.

Le montage n’a pas posé de difficulté particulière on a du mettre environ 15mn avec ma chérie. Je pense que par contre pour quelqu’un plus petit (je mesure 1.80m) cela peut se compliqué au moment d’enfiler la toile sur la structure… Donc pour ces personnes prévoyez un ami (grand) ou un tabouret en faisant attention à  ne pas tomber…

Installation de la lampe :

La lampe que j’ai commandé comprend l’ampoule, le réflecteur et 2 fixation rapides appelés « easy rollers ». Les fixations ne sont pas pratique par rapport au support de la GrowBox. En effet ils sont prévu pour être accrochés à  des crochets or la GrowBox ne présente que des barres trop grosses pour mettre les easy rollers. J’ai donc du passer par une petite étape de bricolage improvisé :

Remplissage :

La boite mesurant 1m² J’ai pu y ranger mes orangers mais aussi beaucoup de plantes qui étaient dans mon salon. Ce qui fit plutôt plaisir à  ma copine ! Le seul hic, les plantes de petite taille ont moins de lumière car les orangers leur font de l’ombre mais bon c’est toujours mieux que ma fenêtre qui se voit masquer le soleil par l’immeuble d’en face.

Premières impressions :

La GrowBox a l’aire vraiment solide et le textile horticole de très bonne qualité. Les plantes vont être mieux dedans que la ou elles étaient. De plus il fait bien plus chaud sous la Box que dans l’appartement. C’est aussi bien plus esthétique que mes boites en bois qui font vraiment bricolage à  côté.

Retour après 6 mois d’utilisations :

Il y’a trop de lumière et pas assez de CO2. J’ai donc acheté des extracteurs. Ceux-ci sont très bruyants et pas super efficaces. J’ai donc trouver une astuce que je vais mettre en place prochainement. Le manque de CO2 à  causé une chlorose apicale de certains orangers. La ils sont en train de s’en remettre tranquillement…La qualité de la toile est confirmé c’est vraiment du costaud !

Conclusion :

Je suis vraiment content de cet investissement, ma copine aussi et surtout, mes plantes ! C’est un investissement mais c’est vraiment efficace. Voici quelques photos pour vous faire une idée du montage :

A sa droite c’est ma deuxième GrowBox que je détaillerai dans un autre article.

Sur cette dernière photo les nombreuses petites plantes qui étaient au pieds des orangers ont été migré dans la Box voisine et les grandes plantes regroupés ici 🙂 On voient également que l’extracteur en haut à  droite à  basculé et n’extrait plus grand chose… il va falloir que je remette ça ce soir ^^