Créer un système de surveillance pour un jardin en utilisant un Arduino et un Micro:Bit – V2 afin de surveiller l’humidité et la luminosité du sol, déclencher l’arrosage automatiquement, et afficher les données sur un écran.
Matériel Requis
- Matériel Principal
– Arduino Uno (ou tout autre modèle compatible) – 1 unité
– Micro:Bit – V2 – 1 unité
Capteurs et Actionneurs
– Capteur d’humidité du sol (modèle YL-69 ou similaire) – 1 unité
– Capteur de luminosité (LDR) – 1 unité
– Pompe à eau 5V (modèle submersible) – 1 unité
– Relais 5V (modèle KY-019 ou similaire) – 1 unité
– Écran LCD 16×2 avec interface I2C – 1 unité
- Composants Divers
– Breadboard – 1 unité
– Câbles de connexion (Dupont) – Environ 30 unités (longueur de 10 cm)
– Résistance de 10kΩ – 1 unité (pour le capteur de luminosité)
– Bouteilles en plastique – pour la fabrication de réservoirs d’eau
– Tuyaux ou pailles – pour le système d’arrosage
- Alimentation
– Alimentation pour Arduino (5V, via USB ou adaptateur) – 1 unité
– Alimentation pour Micro:Bit – v2 (2 piles AAA avec support) – 1 unité
Installation
1. Schéma de Branchement
- Arduino
Capteur d’humidité du sol :
VCC → 5V de l’Arduino.
GND → GND de l’Arduino.
Signal → A0 de l’Arduino.
Capteur de luminosité (LDR) :
Une extrémité du LDR → 5V de l’Arduino.
Autre extrémité du LDR → Connectée en série avec une résistance de 10kΩ.
Jonction LDR/Résistance → A1 de l’Arduino.
Autre extrémité de la résistance → GND de l’Arduino.
Pompe à eau via Relais :
Pompe → Connectée au relais.
Relais :
Broche de contrôle du relais → D7 de l’Arduino.
GND du relais → GND de l’Arduino.
VCC du relais → 5V de l’Arduino.
Écran LCD :
SDA → A4 de l’Arduino.
SCL → A5 de l’Arduino.
VCC → 5V de l’Arduino.
GND → GND de l’Arduino.
- Micro:Bit
Communication Série :
Broche TX de l’Arduino (D1) → Broche P0 (Réception des données).
GND de l’Arduino → GND (Référence de masse commune).
Alimentation
Option 1 : Câble Micro-USB : Connectez le Micro
à une source d’alimentation externe (ordinateur, batterie externe) via un câble micro-USB.
Option 2 : Support de Piles AAA : Utilisez un support de piles AAA pour une alimentation autonome.
2. Détails des Connexions
Capteur d’humidité : Mesure l’humidité du sol et envoie une valeur analogique à l’Arduino.
Capteur de luminosité (LDR) : Mesure la lumière ambiante, avec une résistance de 10kΩ en série pour créer un diviseur de tension. Cette configuration permet à l’Arduino de lire la luminosité via une valeur analogique.
Relais et Pompe : Le relais est contrôlé par l’Arduino pour activer ou désactiver la pompe en fonction du niveau d’humidité mesuré.
Écran LCD : Affiche les données de l’humidité et de la luminosité. Il est connecté via les broches SDA et SCL pour une communication I2C.
Micro:Bit Reçoit les données de l’Arduino via la communication série sur la broche P0. L’alimentation doit être fournie indépendamment par un câble micro-USB ou des piles AAA.
3. Alimentation
Arduino : Alimentation via USB ou via une alimentation externe connectée à la prise DC ou aux broches Vin/GND.
Micro:Bit Alimentation via câble micro-USB ou support de piles AAA.
4. Remarques Importantes
Ne pas connecter simultanément un câble USB et un support de piles au Micro:bit pour éviter les conflits d’alimentation.
GND Commun : Assurez-vous que le GND de l’Arduino et le GND du Micro:bit sont connectés ensemble pour une communication série correcte.
Code
- Arduino
Bibliothèques Requises
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
Code :
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
// Initialisation de l’écran LCD (adresse I2C 0x27, colonnes, lignes)
LiquidCrystal_I2C lcd(0x27, 16, 2);
// Broches des capteurs et relais
const int moisturePin = A0;
const int lightPin = A1;
const int relayPin = 7;
void setup() {
// Initialisation de l’écran LCD
lcd.begin();
lcd.backlight();
// Initialisation des broches
pinMode(moisturePin, INPUT);
pinMode(lightPin, INPUT);
pinMode(relayPin, OUTPUT);
// Initialisation du relais
digitalWrite(relayPin, LOW);
// Initialisation de la communication série
Serial.begin(9600);
}
void loop() {
int moistureLevel = analogRead(moisturePin);
int lightLevel = analogRead(lightPin);
// Affichage des niveaux sur l’écran LCD
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Humidite: “);
lcd.print(moistureLevel);
lcd.setCursor(0, 1);
lcd.print(“Luminosite: “);
lcd.print(lightLevel);
// Envoi des données au Micro:bit
Serial.print(“H:”);
Serial.print(moistureLevel);
Serial.print(“,L:”);
Serial.println(lightLevel);
// Arrosage automatique si le sol est trop sec
if (moistureLevel < 300) {
digitalWrite(relayPin, HIGH); // Active la pompe
delay(5000); // Pompe pendant 5 secondes
digitalWrite(relayPin, LOW); // Désactive la pompe
}
delay(2000); // Pause avant la prochaine lecture
}
1. Inclusion des Bibliothèques
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Wire.h> : Cette bibliothèque est utilisée pour la communication I2C (Inter-Integrated Circuit) entre l’Arduino et d’autres périphériques. L’I2C est un protocole qui permet à plusieurs périphériques de communiquer avec le microcontrôleur via seulement deux fils : SDA (données) et SCL (horloge).
#include <LiquidCrystal_I2C.h> : Cette bibliothèque permet de contrôler un écran LCD via une interface I2C. Elle simplifie l’interaction avec l’écran pour l’affichage de texte.
2. Initialisation de l’Écran LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);
LiquidCrystal_I2C lcd(0x27, 16, 2); : Cette ligne crée un objet lcd pour contrôler l’écran LCD via I2C.
0x27 : C’est l’adresse I2C de l’écran LCD. Cette adresse peut varier selon le module utilisé.
16, 2 : Cela indique que l’écran a 16 colonnes et 2 lignes.
3.Définition des Broches des Capteurs et du Relais
const int moisturePin = A0;
const int lightPin = A1;
const int relayPin = 7;
const int moisturePin = A0; : Déclare la broche analogique A0 pour lire le capteur d’humidité du sol.
const int lightPin = A1; : Déclare la broche analogique A1 pour lire le capteur de luminosité (LDR).
const int relayPin = 7; : Déclare la broche numérique D7 pour contrôler le relais qui activera la pompe à eau.
4. Configuration du Programme dans la Fonction setup()
void setup() {
// Initialisation de l’écran LCD
lcd.begin();
lcd.backlight();
// Initialisation des broches
pinMode(moisturePin, INPUT);
pinMode(lightPin, INPUT);
pinMode(relayPin, OUTPUT);
// Initialisation du relais
digitalWrite(relayPin, LOW);
// Initialisation de la communication série
Serial.begin(9600);
}
lcd.begin(); : Initialise l’écran LCD avec les paramètres définis plus tôt (adresse I2C, dimensions de l’écran).
lcd.backlight(); : Allume le rétroéclairage de l’écran pour rendre le texte visible.
pinMode(moisturePin, INPUT); et pinMode(lightPin, INPUT); : Configure les broches A0 et A1 comme entrées pour lire les valeurs des capteurs.
pinMode(relayPin, OUTPUT); : Configure la broche D7 comme sortie pour contrôler le relais.
digitalWrite(relayPin, LOW); : Met la broche D7 à LOW (0V) pour s’assurer que le relais est désactivé au démarrage.
Serial.begin(9600); : Initialise la communication série à 9600 bauds, permettant d’envoyer des données à d’autres appareils comme le Micro:Bit.
5. Boucle Principale dans la Fonction loop()
void loop() {
int moistureLevel = analogRead(moisturePin);
int lightLevel = analogRead(lightPin);
// Affichage des niveaux sur l’écran LCD
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(“Humidite: “);
lcd.print(moistureLevel);
lcd.setCursor(0, 1);
lcd.print(“Luminosite: “);
lcd.print(lightLevel);
// Envoi des données au Micro:bit
Serial.print(“H:”);
Serial.print(moistureLevel);
Serial.print(“,L:”);
Serial.println(lightLevel);
// Arrosage automatique si le sol est trop sec
if (moistureLevel < 300) {
digitalWrite(relayPin, HIGH); // Active la pompe
delay(5000); // Pompe pendant 5 secondes
digitalWrite(relayPin, LOW); // Désactive la pompe
}
delay(2000); // Pause avant la prochaine lecture
}
int moistureLevel = analogRead(moisturePin); : Lit la valeur analogique du capteur d’humidité (entre 0 et 1023) et la stocke dans moistureLevel.
int lightLevel = analogRead(lightPin); : Lit la valeur analogique du capteur de luminosité et la stocke dans lightLevel.
Affichage sur l’Écran LCD
lcd.clear(); : Efface l’écran avant d’afficher de nouvelles valeurs.
lcd.setCursor(0, 0); : Place le curseur au début de la première ligne.
lcd.print(“Humidite: “); : Affiche le texte “Humidite: ” sur l’écran.
lcd.print(moistureLevel); : Affiche la valeur d’humidité du sol.
lcd.setCursor(0, 1); : Place le curseur au début de la deuxième ligne.
lcd.print(“Luminosite: “); et lcd.print(lightLevel); : Affiche le texte “Luminosite: ” suivi de la valeur de luminosité.
Envoi des Données au Micro:Bit – v2
Serial.print(“H:”);, Serial.print(moistureLevel); : Envoie la valeur d’humidité du sol via la communication série, précédée de “H:”.
Serial.print(“,L:”);, Serial.println(lightLevel); : Envoie la valeur de luminosité, précédée de “,L:”. Le Serial.println() ajoute une nouvelle ligne après l’envoi, indiquant la fin de l’envoi.
Arrosage Automatique
if (moistureLevel < 300) { : Si le niveau d’humidité est inférieur à 300, cela signifie que le sol est sec.
digitalWrite(relayPin, HIGH); : Active le relais, ce qui allume la pompe.
delay(5000); : Maintient la pompe active pendant 5 secondes.
digitalWrite(relayPin, LOW); : Désactive le relais, ce qui éteint la pompe.
delay(2000); : Fait une pause de 2 secondes avant de recommencer la boucle.
- Micro:bit – V2
Code
from microbit import *
import radio
# Initialisation de la radio
radio.on()
while True:
# Réception des données de l’Arduino
incoming = radio.receive()
if incoming:
display.scroll(incoming)
sleep(2000)
display.clear()
Détails du code MicroPython pour le Micro :
1. Importation des Modules
from Micro:Bit import *
import radio
from Micro:Bit import * : Cette ligne importe toutes les fonctions et classes nécessaires pour interagir avec le Micro:Bit. Cela inclut les fonctions pour contrôler l’affichage LED, lire les broches, gérer les boutons, etc.
import radio : Ce module permet d’utiliser la radio intégrée du Micro:Bit pour communiquer sans fil avec d’autres Micro:Bit ou appareils compatibles.
2. Initialisation de la Radio
radio.on()
radio.on() : Active la radio du Micro:Bit, permettant ainsi de recevoir et d’envoyer des messages via ondes radio. Sans cette commande, la radio serait désactivée par défaut.
3. Boucle Principale
while True:
# Réception des données de l’Arduino
incoming = radio.receive()
if incoming:
display.scroll(incoming)
sleep(2000)
display.clear()
while True: : Crée une boucle infinie, faisant fonctionner le code de manière continue tant que le Micro:Bit est allumé.
Réception des Données
incoming = radio.receive() : Cette ligne écoute les ondes radio pour recevoir un message. Si un message est reçu, il est stocké dans la variable incoming. Si aucun message n’est reçu, incoming sera None.
Affichage des Données Reçues
if incoming: : Vérifie si un message a été reçu (si incoming n’est pas None).
display.scroll(incoming) : Fait défiler le message reçu sur l’écran LED du Micro:Bit. Le message peut contenir des informations envoyées par l’Arduino, comme les niveaux d’humidité et de luminosité.
sleep(2000) : Fait une pause de 2 secondes après l’affichage du message pour permettre une lecture complète.
display.clear() : Efface l’affichage LED du Micro:Bit, après le défilement du message.
Fonctionnement Global
Ce code transforme le Micro:Bit en un récepteur sans fil pour les données envoyées par l’Arduino. Lorsque l’Arduino envoie les niveaux d’humidité et de luminosité via la radio, le Micro:Bit les reçoit et les affiche sur son écran LED, offrant ainsi une visualisation instantanée et sans fil des données du jardin.
Le Micro:Bit écoute en permanence les messages radio. Lorsqu’il reçoit un message (envoyé par l’Arduino), il l’affiche sur son écran. Après l’affichage, il fait une pause puis efface l’écran, prêt à recevoir un nouveau message.
Vérifications du projet
Préparation des Capteurs : Connectez les capteurs d’humidité et de luminosité à l’Arduino conformément au schéma.
Installation de la Pompe à Eau : Connectez la pompe à eau via le relais, et installez le tuyau de sortie de la pompe vers le jardin.
Configuration de l’Écran LCD : Connectez l’écran LCD à l’Arduino en utilisant le schéma de connexion standard.
Programmation : Téléversez le code sur l’Arduino et le Micro:Bit respectivement.
Alimentation : Assurez-vous que l’Arduino et le Micro:Bit sont correctement alimentés.
Montage : Fixez les composants dans des boîtiers recyclés pour les protéger des conditions extérieures.
Ce projet allie la surveillance de l’humidité et de la luminosité du sol avec un système d’arrosage automatisé, tout en utilisant des matériaux recyclés pour réduire les coûts et promouvoir la durabilité. C’est une démonstration pratique de l’utilisation de l’électronique pour des solutions efficaces et écologiques.