Dans un nombre de villes croissant, la tendance est à la production de fruits et légumes biologiques ou même autoproduits. Le temps consacré à l’entretien des plantes est peut-être une cause dissuasive. C’est pourquoi ce projet consiste à créer une serre Raspberry Pi automatisée, qui réduit le travail au minimum.
Grâce à l’arrosage, l’aération et l’exposition automatiques, seule la récolte doit être effectuée manuellement à la fin. Toutes les actions (comme l’irrigation) sont contrôlées par des capteurs afin de fournir un résultat optimal. Grâce à sa faible consommation d’espace (environ 1/2 m²), il convient également au balcon urbain.
Liste d’achats
Comme la serre Raspberry Pi doit fonctionner de manière aussi autonome que possible, tout ce qui est nécessaire doit être automatisé. Par conséquent, de nombreux accessoires sont nécessaires. Pour un balcon, il est préférable d’utiliser les accessoires suivants :
- Cadre froid, par exemple 100×60 cm
- Boîtes à fleurs
- Raspberry Pi
- Alimentation 12V 2a
- Adaptateur jack d’alimentation ADC
- Pompe submersible 12V / pompe à eau pour l’étang
- Seau de 10L ou 20L avec couvercle
- quelques tuyaux de 7mm (1.5-2m)
- Module RTC DS1307
- MCP3008 ADC
- Divers capteurs d’humidité du sol (30-40 cm chacun)
- Servomoteur
- Capteur de lumière
- Résistance 10kΩ
- LED 12V
- Relais Reed (min 2)
- Boîtier étanche (ou équivalent).
- Ruban d’isolation
- Câble jumper
- Mini Breadboard (ou perfboard pour la soudure)
- Semences (les meilleures plantes à faible croissance : )
- Tomates (Balconi Rouge)
- Laitue
- radis
- Si vous connaissez d’autres variétés, je serais heureux de recevoir un commentaire.
- Terreau + éventuels engrais
J’utilise deux des pompes à eau, car j’ai semé dans deux jardinières. Vous pouvez varier le nombre de capteurs pour l’humidité du sol.
Bien sûr, vous pouvez adapter les pièces à votre projet. Si vous avez un cadre froid / une serre plus grande, par exemple, vous pouvez ajuster / optimiser le code ci-dessous pour vos besoins.
Si vous voulez utiliser les GPIOs ci-dessous pour l’alimentation électrique, vous aurez également besoin de ceci :
- Régulateur L7805
- Condensateur 2x 10μF
- optimale : résistance 470Ω.
- optimale : LED verte
Contenus
- Installation des bibliothèques requises
- Alimentation via GPIOs
- Composants
- Activation de la serre Raspberry Pi
- Extensions possibles
Installation des bibliothèques requises
Il est préférable de prendre un Raspbian Jessie fraîchement installé et d’ouvrir un terminal (par exemple via SSH). Tout d’abord, nous mettons tout à jour et installons quelques paquets :
sudo apt-get update --yes && sudo apt-get upgrade --yes sudo apt-get install build-essential python-dev python-pip python-smbus python-openssl git --yes
Le processus peut prendre un certain temps. Vous pouvez commencer à construire le foyer.
Entrez à présent sudo raspi-config et sélectionnez « Interfacing Options » -> « SPI » et activez-le. Même chose avec « I2C ». Redémarrez.
Nous installons ensuite les bibliothèques nécessaires.
- SpiDev:
git clone https://github.com/doceme/py-spidev cd py-spidev sudo python setup.py install cd ..
- Adafruits Library pour les DHT11 / DHT22 (alternativement et directement à partir de GitHub):
sudo pip install adafruit_python_dht
Alimentation via GPIOs
En principe, vous avez deux façons de connecter le Raspberry Pi à l’alimentation. La première option est généralement le port Micro USB. L’inconvénient, cependant, est que vous avez normalement besoin de deux prises.
C’est pourquoi je montre d’abord comment alimenter le Raspberry Pi par les GPIOs
. La prudence est requise, car une tension trop élevée peut détruire le Pi ! Si vous ne vous sentez pas en sécurité, choisissez l’alimentation par câble USB..
Le régulateur de tension L7805 ( fiche technique ) peut réduire les tensions de 7 à 25V à 5V. Cependant, deux condensateurs sont encore nécessaires. La connexion est la suivante :
Avant de le connecter au Raspberry Pi, vous pouvez mesurer la tension avec un multimètre.
Les détails peuvent être trouvés ici.
Serre Raspberry Pi – Composants
Premièrement, vous pouvez suivre chaque étape et ainsi développer le code du programme ou, comme décrit à la fin du tutoriel, télécharger le code du dépôt Github et l’ajuster ensuite.
Ce tutoriel doit être aussi personnalisable que possible, car chacun a d’autres conditions. C’est pourquoi la partie suivante est divisée en différentes sections individuelles. Ainsi, si vous souhaitez omettre certains composants (par exemple, pas d’horloge en temps réel ou pas d’éclairage), vous pouvez omettre cette partie ou l’adapter en conséquence.
Mais d’abord, les réglages des GPIOs etc. Dans un nouveau dossier
(mkdir Raspberry-Pi-Greenhouse && cd Raspberry-Pi-Greenhouse) nous créons un fichier (sudo nano greenhouse.py) avec le contenu suivant:
|
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 |
import RPi.GPIO as GPIO import Adafruit_DHT from MCP3008 import MCP3008 import SDL_DS1307 import time ################################################################## ##################### CUSTOMIZEABLE SETTINGS ##################### ################################################################## SETTINGS = { "LIGHT_GPIO": 17, # GPIO Number (BCM) for the Relay "LIGHT_FROM": 10, # from which time the light can be turned on (hour) "LIGHT_UNTIL": 20, # until which time (hour) "LIGHT_CHANNEL": 0, # of MCP3008 "LIGHT_THRESHOLD": 500, # if the analog Threshold is below any of those, the light will turn on "DHT_GPIO": 27, # GPIO Number (BCM) of the DHT Sensor "DHT_SENSOR": Adafruit_DHT.DHT22, # DHT11 or DHT22 "TEMP_THRESHOLD": 23.0, # in Celcius. Above this value, the window will be opened by the servo "SERVO_GPIO": 22, # GPIO Number (BCM), which opens the window "SERVO_OPEN_ANGLE": 90.0, # degree, how much the servo will open the window "PLANTS": [ { "NAME": "Tomaten", "MOISTURE_CHANNELS": [1, 2], # of MCP3008 "MOISTURE_THRESHOLD": 450, # if the average analog value of all sensors is above of this threshold, the Pump will turn on "WATER_PUMP_GPIO": 23, # GPIO Number (BCM) for the Relais "WATERING_TIME": 10, # Seconds, how long the pump should be turned on }, { "NAME": "Salat", "MOISTURE_CHANNELS": [3, 4], "MOISTURE_THRESHOLD": 450, "WATER_PUMP_GPIO": 24, "WATERING_TIME": 12, }, ] } ################################################################## ################# END OF CUSTOMIZEABLE SETTINGS ################## ################################################################## |
Si vous voulez d’autres GPIO ou d’autres paramètres, vous pouvez les ajuster ici.
Dans les sections suivantes, nous étendons les fonctions (si vous le souhaitez). Vous pouvez trouver le pinout des GPIOs dans cette image.
Préparation de la serre Raspberry Pi
Avant d’installer les composants électroniques, il faut construire le cadre froid. Vous pouvez y placer 2 ou 3 grands jardinières (en fonction de leur taille). Vous pouvez y mettre de jeunes plantes ou des graines. Faites attention aux instructions figurant sur l’emballage.
En outre, il est nécessaire de fertiliser le sol. Si vous voulez, vous pouvez aussi prendre du compost spécial tomates ou légumes, qui contient plus de minéraux.
Régler l’heure
Si le Pi redémarre (par exemple après une panne de courant), il ne connaît pas l’heure et la date actuelles, s’il n’y a pas de connexion Internet. Par conséquent, les modules d’horloge en temps réel, qui ont une batterie, sont utilisés pour enregistrer la date et l’heure de façon permanente. Cette étape est facultative et peut être omise s’il existe une connexion Internet permanente.
Il est important que les deux résistances (R2 et R3) soient retirées du Tiny RTC (modules I2c) avec un fer à souder. Typiquement, ces modules renvoient des signaux de 5V, ce qui est trop pour le Raspberry Pi. Alternativement, vous pouvez utiliser un TTL 3.3V-5V.
Commençons par la connexion:
| Module RTC | Raspberry Pi |
|---|---|
| SCL | GPIO 3 / SCL (Broche 5) |
| SDA | GPIO 2 / SDA (Broche 3) |
| VCC / 5V | 5V ( Broche 2 ou Broche 4) |
| GND | GND (broche 6) ou toute autre broche GND |
Premièrement, nous chargeons le script requis :
wget https://raw.githubusercontent.com/tutRPi/Raspberry-Pi-Greenhouse/master/SDL_DS1307.py
Nous réglons ensuite l’heure et le fuseau horaire corrects:
sudo raspi-config
Sous le menu « Localization Options », vous pouvez définir votre fuseau horaire. Vous pouvez ensuite utiliser la date pour vérifier si l’heure est correcte. Ouvrez ensuite la console Python (sudo python) et entrez ce qui suit pour régler l’heure du RTC :
import SDL_DS1307 ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68) ds1307.write_now() exit()
Cela permet de sauvegarder l’heure actuelle.
Maintenant nous pouvons étendre notre script actuel (sudo nano greenhouse.py):
|
66 67 68 69 70 71 72 |
def readTime(): try: ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68) return ds1307.read_datetime() except: # alternative: return the system-time: return datetime.datetime.utcnow() |
Sauvegardez avec CTRL + O.
Ajuster la luminosité
Pour que les plantes reçoivent suffisamment de lumière même pendant les jours de nuages, nous prolongeons la serre par une LED lumineuse de ~20 cm. Vous pouvez également utiliser une bande de LED (résistante à l’eau) et l’utiliser comme éclairage supplémentaire. Cependant, l’éclairage artificiel ne s’allume que lorsqu’il fait nuit. C’est pourquoi nous utilisons un capteur de lumière, qui émet une valeur de luminosité analogique, que nous pouvons lire avec un ADC MCP3008.
Il existe également des modules de capteurs de lumière qui fournissent déjà une valeur numérique, indiquant si la valeur de luminosité est supérieure ou inférieure à une valeur seuil. Si vous voulez l’utiliser, vous devez ajuster légèrement le code.
Le circuit intégré MCP3008 possède 8 entrées sur lesquelles des signaux analogiques peuvent être lus. Tout d’abord, nous connectons tout :
| Raspberry Pi | MCP3008 |
|---|---|
| Broche 1 (3.3V) | Broche 16 (VDD) |
| Broche 1 (3.3V) | Broche 15 (VREF) |
| Broche 6 (GND) | Broche 14 (AGND) |
| Broche 23 (SCLK) | Broche 13 (CLK) |
| Broche 21 (MISO) | Broche 12 (DOUT) |
| Broche 19 (MOSI) | Broche 11 (DIN) |
| Broche 24 (CE0) | Broche 10 (CS/SHDN) |
| Broche 6 (GND) | Broche 9 (DGND) |
Un des 8 canaux est utilisé pour le capteur de lumière (canal 0). Nous le connectons via une résistance pull-up comme indiqué sur la figure. Nous connectons également le relais (VCC à 5V, GND à GND et, par exemple, IN1 à GPIO17). Si vous alimentez le Raspberrry Pi via le L7805, vous pouvez également y prélever directement la tension de 5V.
De l’autre côté du relais, la borne positive de la connexion 12V est connectée à la borne centrale et la connexion (+) à la LED à l’extrémité inférieure. Le GND de la bande de LED est également connecté au GND de la prise.
D’abord nous chargeons un fichier avec une classe Python pour le MCP3008, que nous pouvons intégrer :
wget https://raw.githubusercontent.com/tutRPi/Raspberry-Pi-Greenhouse/master/MCP3008.py
A présent, nous élargissons à nouveau le code :
|
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
def checkLight(): timestamp = readTime() if SETTINGS["LIGHT_FROM"] <= timestamp.hour <= SETTINGS["LIGHT_UNTIL"]: # check light sensors adc = MCP3008() # read 10 times to avoid measuring errors value = 0 for i in range(10): value += adc.read( channel = SETTINGS["LIGHT_CHANNEL"] ) value /= 10.0 if value <= SETTINGS["LIGHT_THRESHOLD"]: # turn light on GPIO.setup(SETTINGS["LIGHT_GPIO"], GPIO.OUT, initial=GPIO.LOW) # Relay LOW = ON else: # turn light off GPIO.setup(SETTINGS["LIGHT_GPIO"], GPIO.OUT, initial=GPIO.HIGH) else: # turn light off GPIO.setup(SETTINGS["LIGHT_GPIO"], GPIO.OUT, initial=GPIO.HIGH) |
Arrosage automatique
L’irrigation par l’humidité du sol est l’élément central de la serre. Pour cela, nous avons besoin des pompes submersibles, d’un tuyau et d’un relais pour chaque pompe. Les capteurs d’humidité sont lus par le MCP3008 connecté précédemment.
Comme ces minipompes fonctionnent également avec 12V, des relais sont également nécessaires. Dans mon cas, j’ai deux pompes (une par jardinière). Si vous en utilisez plus de 3, vous devriez choisir une carte relais avec plus de canaux.
D’abord, nous attachons le tuyau à la pompe. A côté du jardinière, je mets un seau d’eau (voir les images à la fin). Le tuyau doit être assez long pour aller de ce seau jusqu’à l’extrémité de la jardinière. J’ai scellé l’extrémité du tuyau avec de la colle chaude et j’ai percé des petits trous dans le tuyau tous les 10-15 cm. Comme la pression augmente grâce à la pompe, les trous doivent être très petits. J’ai utilisé une épaisseur de foret de 1-2mm.
Puis j’ai attaché le tuyau au bord de la jardinière. De l’autre côté d’un trou, j’ai placé un capteur d’humidité du sol. Ensuite, on calcule l’humidité moyenne du sol et on décide de verser ou non. Les broches analogiques des capteurs d’humidité du sol sont connectées au MCP3008. Une piste conductrice mène à GND via une résistance de 10 k ohm.
Si vous utilisez plus de 7 capteurs, vous avez besoin d’un autre MCP3008 ADC (la première place est réservée au capteur de lumière). De plus, chaque capteur est alimenté par les 3.3V du Raspberry Pi :
Les GPIO qui contrôlent les relais peuvent également être définis dans les paramètres au début du fichier. Pour mes deux pompes, ce sont les GPIO 23 et 24.
Voici le code correspondant :
|
98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 |
def wateringPlants(): # read moisture adc = MCP3008() for plantObject in SETTINGS["PLANTS"]: value = 0 for ch in plantObject["MOISTURE_CHANNELS"]: # read 10 times to avoid measuring errors v = 0 for i in range(10): v += adc.read( channel = ch ) v /= 10.0 value += v value /= float(len(plantObject["MOISTURE_CHANNELS"])) if value > plantObject["MOISTURE_THRESHOLD"]: # turn pump on for some seconds GPIO.setup(plantObject["WATER_PUMP_GPIO"], GPIO.OUT, initial=GPIO.LOW) time.sleep(plantObject["WATERING_TIME"]) GPIO.output(plantObject["WATER_PUMP_GPIO"], GPIO.HIGH) |
Ventilation
Selon le foyer ou la serre, il y a plusieurs fenêtres ouvrables. Pour un lit précoce, il n’y en a généralement pas plus de deux. Pour ouvrir une fenêtre, j’utilise un servo avec un long bâton en bois attaché à l’axe. Dans l’état initial, l’angle doit être de 0°. Si vous n’êtes pas sûr, vous devriez régler le servo une fois par script sur 0° et ensuite l’attacher :
Le servo est fixé à l’intérieur avec du ruban adhésif double face résistant.
La valeur de la température est utilisée à des fins de contrôle. Pour cela, nous devons encore connecter le capteur de température DHT11 au GPIO 27, tandis que le servo moteur est connecté au GPIO 22. Comme le moteur a probablement besoin de plus de 3.3V (voir la fiche technique, si vous n’êtes pas sûr), nous le connectons à la tension de 5V :
J’ai le capteur DHT simplement fixé au boîtier étanche (point suivant). Pour modifier la température à laquelle la trappe doit être ouverte, vous pouvez modifier les paramètres initiaux.
En outre, le code doit être étendu :
|
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 |
def checkWindow(): # read remperature humidity, temperature = Adafruit_DHT.read_retry(SETTINGS["DHT_SENSOR"], SETTINGS["DHT_GPIO"]) GPIO.setup(SETTINGS["SERVO_GPIO"], GPIO.OUT) pwm = GPIO.PWM(SETTINGS["SERVO_GPIO"], 50) if temperature > SETTINGS["TEMP_THRESHOLD"]: # open window angle = float(SETTINGS["SERVO_OPEN_ANGLE"]) / 20.0 + 2.5 pwm.start(angle) else: # close window pwm.start(2.5) # save current time.sleep(2) pwm.ChangeDutyCycle(0) |
Si vous avez des problèmes pour lire (« ImportError: No module named Raspberry_Pi_Driver« ), ce post peut vous aider. Alternativement, vous pouvez aussi utiliser GPIO 4, qui est toujours libre dans mon câblage.
Boîtier et montage étanches
Dans la dernière étape du montage, nous emballons les éléments de commande importants dans un boîtier étanche. Le Raspberry Pi ainsi que les relais et tout ce qui est sensible à l’eau doivent se trouver à l’intérieur. J’ai percé un trou sur le côté inférieur et tous les câbles qui doivent y entrer ou en sortir.
En outre, les composants peuvent être soudés à une grille de trous une fois que tout a été testé.
Au minimum, l’électronique et les connexions potentiellement dangereuses doivent être maintenues à l’abri de l’eau. Il est préférable de choisir un endroit couvert.
Activation de la serre Raspberry Pi
A présent que nous avons connecté et installé tous les composants, faisons en sorte que tout fonctionne automatiquement. Pour ce faire, nous étendons le script en appelant les fonctions créées en séquence :
|
138 139 140 141 142 143 144 145 146 147 148 149 |
if __name__ == '__main__': try: GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) # execute functions checkLight() wateringPlants() checkWindow() except: GPIO.cleanup() |
Au fait : Si vous voulez télécharger tous les fichiers en une fois, vous pouvez le faire via ma bibliothèque GitHub :
git clone https://github.com/tutRPi/Raspberry-Pi-Greenhouse
Le script doit être appelé automatiquement toutes les 10 minutes, nous utilisons donc Cron :
crontab -e
Ici, nous ajoutons une ligne à la fin, qui invoque notre script toutes les 10 minutes :
*/10 * * * * sudo python /home/pi/Raspberry-Pi-Greenhouse/greenhouse.py > /dev/null 2>&1
Avec CTRL + O on sauvegarde et on retourne au terminal avec CTRL + X.
A propos : Vous pouvez trouver le chemin absolu d’un répertoire avec cd puis en entrant pwd.
Maintenant, vous n’avez rien d’autre à faire que d’attendre. Pour économiser de l’énergie, vous pouvez désactiver le wifi et les autres services inutiles.
Extensions possibles de la serre Raspberry Pi
Même s’il y a déjà beaucoup de choses disponibles, vous pouvez certainement en ajouter. Je propose les points suivants, dont je peux également mettre en œuvre l’un ou l’autre si nécessaire. Si vous avez des idées, n’hésitez pas à laisser un commentaire.
- Niveau d’eau : Bien que nous irriguions les plantes automatiquement, nous devons cependant verser de l’eau dans le seau. Avec une mesure du niveau de remplissage, nous pourrions envoyer un message par exemple par l’application Telegram dès que l’eau doit être remplie. Il est également possible d’installer un témoin lumineux (LED).
- Mesurer l’humidité : Le capteur DHT11 ou DHT22 peut mesurer l’humidité en plus de la température. Cependant, nous ne l’utilisons pas pour l’instant. Il serait concevable d’amener l’humidité à un certain niveau à l’aide de pulvérisateurs d’eau. Cela dépend bien sûr des plantes.
- Chaleur : il peut parfois faire plus froid, surtout au printemps ou en automne. Afin de créer des conditions optimales pour les plantes, on peut également chauffer l’air de la serre..
- Refroidir activement : Jusqu’à présent, nous ne refroidissons que passivement (ouverture / fermeture de la fenêtre). Grâce à un ventilateur, nous pourrions également refroidir activement à des températures élevées.
- Écran LCD : En outre, nous pouvons également utiliser un écran LCD afin de voir les données actuelles sur un écran..
PS : Nous vous invitons à nous envoyer des photos de votre serre ou serre automatique Raspberry Pi.
Un commentaire
Bonjour,
Je vois votre site web http://www.raspberrypi-tutorials.fr et c’est impressionnant. Je me demande si des options publicitaires telles que la publication d’invités, le contenu publicitaire sont disponibles sur votre site ?
Quel est le prix si nous voulons faire de la publicité sur votre site ?
À votre santé
Mary com