Ce site utilise des cookies
Vos données sont privées, nous le savons, c'est pour ça qu'on en fait pas n'importe quoi.
×

 

 

 

 

 Le futur est entre vos mains

 

 

Le futur est entre vos mains

jeudi, 22 février 2018 15:13

Petit potager d'interieur DIY connecté

Découvrez comment fonctionnent les objets connectés en vous fabriquant un jardin indoor de plantes aromatiques. 

 

Débutant friendly - Intermédiaire

En 1 jour

Buget 50 €

Vous n'êtes pas familier de l'électronique en général et du code informatique en particulier? Ce tuto utilise des systèmes électroniques simples qui ne nécessitent pas de compétences techniques particulières, pour vous faire découvrir le monde l'IoT pas à pas. Comme pour une recette de cuisine, il suffit de suivre les instructions pour arriver au résultat.

Walter Heger adore mettre des herbes aromatiques dans ses plats. Il s'est donc conçu un petit potager d'interieur connecté à Alexa.

Il s'est fixé pour objectif de créer un système d'irrigation personnalisé et intelligent qui peut fonctionner automiquement ou manuellement. Un capteur d'humidité envoie des données sur une petite interface web afin d'optimiser son petit potager d'intérieur DIY. Enfin, il a complété son installation en intégrant le contrôle d'Alexa pour allumer ou éteindre la lampe de culture et démarrer l'irrigation si l'automatisation est désactivée.
Un excellent tuto, pratique et facile, pour démarrer un jardin indoor et s'initier à l'électronique.

Walter insiste sur le fait qu'il n'était pas familier avec l'environnement Arduino (code et électronique), il n'est donc pas nécessaire de s'y connaître pour faire votre petit jardin.

Le vocabulaire peut sembler un peu technique pour les branchements, cependant si vous respectez le tuto vous n'aurez aucune difficulté. Dans ce tuto, "broche" et "pin" sont des synonymes afin de vous familiariser éventuellement avec le langage électronique, essentiellement en anglais.

Si vous ne connaissez pas l'électronique mais que vous souhaitez faire ce projet, on vous recommande cet excellent cours, bien imagé sur le fonctionnement du microcontrôleur Arduino. Quant à son installation sur votre pc, le guide est ici.

Ce qu'il vous faut :

Vous pouvez acheter des cartes Arduino de la marque Arduino sur n'importe quel revendeur de composants électroniques. Sachez toutefois, qu'Arduino crée des microcontrôleurs open-source, des clones de ces cartes sont donc en vente pour 3 à 4 fois moins cher sur des sites comme Banggood. Nous avons estimé le budget électronique à environ 30€ (cartes clonées) et la partie bois + potager à 20€.

 

Première étape: Capteur d'humidité


La première étape est de lire l'humidité avec son Arduino. Le capteur d'humidité YL-69 est facile à connecter avec l'Arduino. Vous devez connecter la broche VCC à une pin GPIO (dans l'exemple la broche 06), la pin masse (le négatif) à la pin GRD (ground pour terre) et la broche A0 à une pin analogique (dans l'exemple broche A1) de l'Arduino.


Walter s'est resservi d'un précédent tuto de Sorin Trimbitas pour comprendre et coder son capteur d'humidité. Il a reproduit le tuto pour comprendre comment fonctionnait le capteur d'humidité.

byte vccPin = 6;
byte dataPin = A1;
void setup() {
pinMode(vccPin, OUTPUT);
digitalWrite(vccPin, LOW);
Serial.begin(9600);
while (!Serial);
}
int readHumidity() {
digitalWrite(vccPin, HIGH);
delay(500); // you need to test how long you pre-power before measurement
int value = analogRead(dataPin);
digitalWrite(vccPin, LOW);
return 1023 - value;
}
void loop() {
Serial.print("HumidityLevel (0-1023): ");
Serial.println(readHumidity());
delay(10000);
}

 

Deuxième étape: le relais pour les pompes et la lampe

L'objectif suivant est d'installer un shield relais (4 relais) pour séparer les circuits de la lampe, des pompes et de l'Arduino. L'arduino fonctionne sur 5V, les pompes utilisent du 12V et la lampe de culture du 230V. Le shield doit être connecté aux broches 5V et Ground de l'arduino. Chaque relais a également besoin d'une broche GPIO (les pins) de votre choix pour allumer et éteindre.

Dans le code ci-dessous, deux relais sont utilisés sur les quatre, un branché sur la broche 11 de l'arduino, l'autre sur la broche 10. Vous pouvez utiliser des câbles de prototypage pour relier les broches 11 & 10 du shield relais aux broches 11 & 10 de l'arduino.

Un petit schéma de montage pour comprendre le principe.


Il est important de comprendre que le shield s'allume en position basse "LOW" sur la broche. Dès que la broche est définie comme OUTPUT, elle passe automatiquement en position haute "HIGH". Dans le code, vous devriez toujours passer à INPUT et LOW, si vous voulez que le relais soit éteint. Par défaut, les broches Arduino sont INPUT et LOW.
Walter a repris ici un tuto d'Ostin pour comprendre le fonctionnement des relais.

Les relais permettent de contrôler depuis votre microcontrôleur Arduino du courant alternatif (AC) , ce qui est parfait pour des projets domotiques ou iot.
Voici le code pour tester les relais.

byte pump1 = 11;
byte pump2 = 10;
void setup() {
Serial.begin(9600);
while (!Serial);
pinMode(pump1, OUTPUT); // variant low/high
digitalWrite(pump2, LOW); // variant input/output
}
void loop() {
digitalWrite(pump1, HIGH); // pump1 deactivated
pinMode(pump2, INPUT); // pump2 deactivated
delay(1000);
digitalWrite(pump1, LOW); // pump1 activated
pinMode(pump2, OUTPUT); // pump2 activated
delay(1000);
}

Troisième étape: Connecter l'arduino au WiFi avec un ESP-01


Connecter l'ESP8266 ESP-01 à l'arduino pour le WiFi est la partie la plus difficile. Il a fallu des heures à Walter pour faire fonctionner le wifi dans son code.

Similaire à l'Arduino, l'ESP-01 est un autre microcontrôleur. Si vous voulez que les deux contrôleurs communiquent, vous devez utiliser une communication série. L'UNO Arduino utilise par défaut les broches 01 et 02 pour RX et TX. Mais ils sont également utilisés pour le débogage USB et il est donc suggéré d'inclure SoftwareSerial.h et de définir des broches personnalisées.

L'ESP est connecté à: VCC = 3.3V, GND = GND, CH_PD = 3.3V, TX = Pin 02, RX = Pin 03. Pour une bonne utilisation, vous devez utiliser au moins un convertisseur de tension de 5V à 3.3V pour la broche 02 et la broche 03, aussi.
dans le code ci-dessous les pins RX/TX du esp sont définis dans le code et branchés sur les pins 3 (RX) et 2 (TX) de l'Arduino.

un petit schéma pour brancher tout ça.

 

#include <SoftwareSerial.h>
SoftwareSerial espSerial(3,2); // RX, TX
void setup() {
Serial.begin(9600);
espSerial.begin(115200); // switch to 9600 after AT+UART_DEF=9600,8,1,0,0
while (!Serial);
}
void loop() {
if (espSerial.available()) {
Serial.write(espSerial.read());
}
if (Serial.available()) {
espSerial.write(Serial.read());
}
}

En exécutant le script ci-dessus, vous pouvez entrer des commandes AT dans le moniteur série et voir les résultats. La communication série est sujette à l'échec, donc Walter a diminué le débit en bauds de communication utilisé par l'ESP de 115200 à 9600 (réglable en un clic sur l'interface IDE Arduino).

Pour comprendre les commandes AT (ces commandes qui permettent de communiquer entre l'arduino et l'esp) voici un excellent cours sur le fonctionnement du microcontrôleur ESP.

Deux bibliothèques intéressantes pour utliser l'ESP avec Arduino :
Une classe d'aide utile (mais qui utilise trop de mémoire): Bibliothèque: WiFiEsp

Outil de vérification de la mémoire: Bibliothèque: MemoryFree

Le script utilise HTTP 1.0, car avec HTTP 1.1, les octets font partie de la réponse. Il est important de faire attention aux sauts de ligne pour que la commande soit envoyée après AT + CIPSEND. Si elles sont erronées, vous recevrez une erreur d'envoi d'octet.

#include <SoftwareSerial.h>
SoftwareSerial espSerial(3,2); // RX, TX
const char* ssid = "<YOUR-WIFI-SSID>";
const char* pass = "<YOUR-WIFI-PASSWORD>";
void setup() {
Serial.begin(9600);
espSerial.begin(9600);
while(!Serial);
while(!connectToWiFi());
// request website and print result
if (httpRequest("my.server.com", "/site/subsite/index.php")) {
while (espSerial.available()) { Serial.write(espSerial.read()); }
}
}
void loop() { // run over and over
if (espSerial.available()) {
Serial.write(espSerial.read());
}
if (Serial.available()) {
espSerial.write(Serial.read());
}
}
bool connectToWiFi() {
delay(2000;)
espSerial.setTimeout(3000);
while (espSerial.available()) Serial.write(espSerial.read());
Serial.println(F("[ESP] Connecting to WiFi"));
espSerial.println(F("AT+CIPSTATUS=2"));
if (!espSerial.find("OK")) {
espSerial.setTimeout(10000);
Serial.println(F("[ESP] Reset Module"));
espSerial.println(F("AT+RST")); if (!espSerial.find("ready")) { Serial.println(F("[ESP] Reset failed")); return false; }
Serial.println(F("[ESP] Set CWMode"));
espSerial.println(F("AT+CWMODE=1")); if (!espSerial.find("OK")) { Serial.println(F("[ESP] Mode failed")); return false; }
Serial.println(F("[ESP] Connect to Router"));
espSerial.print(F("AT+CWJAP=\""));
espSerial.print(ssid);
espSerial.print(F("\",\""));
espSerial.print(pass);
espSerial.println("\"");
if (!espSerial.find("OK")) { Serial.println(F("[ESP] WiFi connection failed")); return false; }
}
espSerial.setTimeout(3000);
Serial.println(F("[ESP] WiFi is connected"));
return true;
}
bool httpRequest(String server, String site) {
String cmd = "";
cmd += "GET " + site + " HTTP/1.0\r\n";
cmd += "Host: " + server + "\r\n";
cmd += "Connection: close";
int cmdLength = cmd.length() + 4;
// Serial.println(cmd);
espSerial.print(F("AT+CIPSTART=\"TCP\",\""));
espSerial.print(server);
espSerial.println(F("\",80"));
if (!espSerial.find("OK")) { Serial.println(F("[ESP] TCP Connection Error")); return false; }
espSerial.print(F("AT+CIPSEND="));
espSerial.println(cmdLength);
if (!espSerial.find(findGT)) { Serial.println(F("[ESP] Send State Error")); return false; }
espSerial.print(F("GET "));
espSerial.print(site);
espSerial.print(F(" HTTP/1.0\r\n"));
espSerial.print(F("Host: "));
espSerial.print(server);
espSerial.print(F("\r\n"));
espSerial.print(F("Connection: close\r\n"));
espSerial.println();
if (!espSerial.find(":")) { Serial.println(F("Bytes not sent")); espSerial.print(F("AT+CIPCLOSE")); return false; }
char status[32] = {0};
espSerial.readBytesUntil('\r', status, sizeof(status));
if (strcmp(status, "HTTP/1.1 200 OK") != 0) { Serial.print(F("[ESP] Unexpected response: ")); Serial.println(status); return false; }
if (!espSerial.find("\r\n\r\n")) { Serial.println(F("[ESP] Invalid response")); return false; } // Skip HTTP headers
// if (!espSerial.find(\r\n)) { Serial.println(F("[ESP] Bytes not found")); return; } // skip bytes (for http 1.1)
return true;
}

Quatrième étape: la boîte en bois


Le cadre est prévu pour stocker tous les appareils électroniques et trois pots d'herbes aromatiques. Walter a mesuré les tailles de tous les composants et structuré les positions. Quatre capteurs d'humidité, deux pompes, la carte arduino + un shield de relais 4x et une prise USB ainsi que quelques fils doivent être montés dans la boîte. elle a été faite en bois de hêtre, pour la rendre résistante à l'eau.

Les cercles ont été sciés avec une scie à chantourner sur une table. Les supports de plantes sont collés à l'intérieur des cercles avec de la colle chaude. Les côtés de la boîte sont collés avec de la colle à bois (D3 pour la résistance à l'eau). Outre l'eletronique, Walter n'a pas utilisé de vis ou de clous à côté de la fixation du panneau inférieur.

Puis il a mis tous les circuits, fils et tubes d'eau à l'intérieur de la boîte, et sorti les capteurs et les tubes pour le réservoir d'eau supplémentaire. Avant de fermer la boîte, il a ajouté des soucoupes pour empêcher l'eau d'inonder l'intérieur de la boîte et protéger l'électronique.

 

Cinquième étape: l'API et le site Web

Walter s'est fait son propre site et sa propre API pour pour ce projet. Si vous n'êtes pas familier du web-développement on vous propose d'aller directement à l'étape débutant friendly pour intégrer directement votre potager d'intérieur à Alexa, sans coder.

L'API et le site web sont basés sur jQuery , Bootstrap , X-editable (pour les formes ajax en ligne) et Chart.js (pour le diagramme d'humidité), codé en php . Sur le site Web, vous pouvez définir les paramètres de l'Arduino (p. Ex. Broches de capteur, intervalle de vérification de l'humidité, pompes par installation, broches VCC de la pompe, broches VCC légères) et trouver le diagramme d'humidité + actuel.

La configuration est fournie par la bibliothèque JSON pour Arduino. Après le démarrage, la boîte d'herbes aromatiques vérifie les nouveaux paramètres. Pour analyser le JSON avec l'Arduino, Walter a utilisé la bibliothèque ArduinoJson. Pour l'intervalle d'interrogation, il a utilisé StensTimer.

Bibliothèque: ArduinoJson | Bibliothèque: StensTimer

Intégration de Alexa

Le site Web fournit une API pour la communication avec Alexa. Il sert de hub pour recevoir la requête JSON d'Alexa et la traduit en un JSON personnalisé utilisé par l'Arduino (par exemple: lampe allumée, irriguer plante 1, ...). L'Arduino interroge les nouvelles actions et les exécute.
Parce que les demandes vocales sont plus que juste on / off, Walter a implémenté une Alexa Skill et non une Alexa Smart Home. AWS Lampda transmet la demande JSON à son API, qui analyse les intentions.

var https = require('https');
exports.handler = (event, context, callback) => {
var postData = JSON.stringify(event);
var options = {
host: '<MY-SERVER>',
path: '<MY-API-SITE>',
port: 443,
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Content-Length': postData.length,
}
};
// set up the request
var postRequest = https.request(options, function(res) {
res.setEncoding('utf8');
res.on('data', function (chunk) {
console.log('Response: ' + chunk);
// console.log(chunk);
callback(null, JSON.parse(chunk));
});
});
// post the data
postRequest.write(postData);
postRequest.end();
};

Un extrait des intentions que Walter a utilisé par ces skills:

ReadHumidityIntent : Comment sont mes plantes
ReadHumidityIntent : Comment est mon {plantName}
IrrigatePlantIntent : Irriguer mes plantes
IrrigatePlantIntent : Irriguer mon {plantName} pendant {durationSeconds} secondes
SwitchIntent Change : la lampe {switchState}

 

Etape débutant friendly : intégration facile de Alexa avec un ESP

Voici un excellent tuto et surtout code, très bien documenté, pour intégrer Alexa avec un ESP8266. Ce projet fonctionne pour une communication à base d'infrarouge (IR), il suffit d'effacer toutes les fonctions inutiles liées à l'IR et d'intégrer les codes des relais et des capteurs de température pour votre projet diy de jardin indoor.

Le code Arduino est à la fin du tuto. Enregistrez uniquement le fichier ESP8266-Alexa.ino, les deux autres fichiers concernent l'IR.

Et voilà !

Si vous avez fait comme Walter, un site web et son API, votre système est à la fois automatisé ou en mode manuel via les commandes d'Alexa.

Si vous êtes plutôt débutant et que avez sauté l'étape du site web, alors vote petit potager intérieur sera uniquement connecté à Alexa.

Enjoy and share it !

Vous pourriez aimer

Créatifs, faut-il accepter le compromis?

Créatifs, faut-il accepter le compromis?

Créatifs, faut-il accepter le compromis?

L'art de trouver un équilibre pour vivre sa passion, sans vendre son âme.                          

TAKE IT EASY: Pourquoi procrastiner peut aussi vous faire du bien

TAKE IT EASY: Pourquoi procrastiner peut aussi vous faire du bien

TAKE IT EASY: Pourquoi procrastiner peut aussi vous faire du bien

Plus qu'un mode de vie de fainéant, c'est une méthode d'organisation efficace.                                                                                                  

Les chatbots et moi on ne se comprend pas

Les chatbots et moi on ne se comprend pas

Les chatbots et moi on ne se comprend pas

A force de dire qu'ils sont intelligents, on a fini par croire qu'ils étaient humains.       

tuto original de Walter Heger. Credits photo : Walter Heger


TOP