Dans un nombre croissant de villes, la tendance est aux fruits et légumes bio voire auto-cultivés. Le temps consacré à l’entretien des plantes est peut-être une cause dissuasive. Par conséquent, ce projet implique la création d’une serre Raspberry Pi automatisée, ce qui réduit le travail au minimum.
Par arrosage, aération et 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. En raison de la faible consommation d’espace (environ 1/2 m²), il convient également au balcon urbain.
Liste de courses
Les plantes à faible croissance sont particulièrement adaptées à la serre automatique Raspberry Pi.
Étant donné que la serre Raspberry Pi devrait fonctionner de manière aussi autonome que possible, tout ce qui est nécessaire doit être automatisé. Par conséquent, beaucoup d’accessoires sont nécessaires. Pour un balcon, il est préférable d’utiliser les accessoires suivants:
- Cadre froid, par exemple 100 × 60 cm (NOUS | Royaume-Uni)
- Bacs à fleurs
- Tarte aux Raspberry PI (NOUS | Royaume-Uni)
- Alimentation 12V DC (NOUS | Royaume-Uni)
- Adaptateur de prise d’alimentation CC (NOUS | Royaume-Uni)
- Pompe submersible 12V / pompe à eau pour l’étang (NOUS | Royaume-Uni)
- Seau 10L ou 20L avec couvercle
- quelques tuyaux de 7 mm (1,5-2 m)
- Module RTC DS1307 (NOUS | Royaume-Uni)
- MCP3008 ADC (NOUS | Royaume-Uni)
- Plusieurs capteurs d’humidité du sol (30-40 cm chacun) (NOUS | Royaume-Uni)
- Servomoteur (NOUS | Royaume-Uni)
- Capteur de lumière (NOUS | Royaume-Uni)
- Résistance 10kΩ (NOUS | Royaume-Uni)
- LED 12V (NOUS | Royaume-Uni)
- Relais Reed (min 2) (NOUS | Royaume-Uni)
- Boîtier étanche (ou similaire) (NOUS | Royaume-Uni)
- Ruban isolant
- Câble de raccordement (NOUS | Royaume-Uni)
- Mini planche à pain (ou perfboard pour le soudage)
- Graines (meilleures plantes à faible croissance:)
- Tomates (Balconi Red) (NOUS | Royaume-Uni)
- Salade (NOUS | Royaume-Uni)
- Des radis (NOUS | Royaume-Uni)
- Si vous connaissez d’autres variétés, je serais heureux d’un commentaire
- Terreau + éventuellement engrais
J’utilise deux des pompes à eau, car j’ai semé dans deux bacs à fleurs. Vous pouvez faire varier le nombre de capteurs d’humidité du sol.
Bien sûr, vous pouvez adapter les pièces à votre projet. Si vous avez un cadre / serre froid plus grand, par exemple, vous pouvez ajuster / optimiser le code ci-dessous pour vos besoins.
Si vous souhaitez utiliser les GPIO ci-dessous pour l’alimentation, vous en aurez également besoin:
- Régulateur L7805 (NOUS | Royaume-Uni)
- 2x condensateur 10μF (NOUS | Royaume-Uni)
- optimal: Résistance 470Ω
- optimal: LED verte
Contenu
Installation des bibliothèques requises
Il est préférable de prendre un Raspbian fraîchement installé Jessie et ouvrez un terminal (par exemple via SSH). Tout d’abord, nous mettons à jour tout et installons quelques packages:
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 maintenant sudo raspi-config et sélectionnez « Options d’interfaçage » -> « SPI » et activez-le. Idem 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 ..
- Bibliothèque Adafruits pour le DHT11 / DHT22 (alternativement directement depuis GitHub):
sudo pip install adafruit_python_dht
Alimentation via GPIO
En principe, vous avez deux façons de connecter le Raspberry Pi à l’alimentation. Une option est généralement via le port Micro USB. L’inconvénient, cependant, est que vous avez normalement besoin de deux sockets.
Par conséquent, je montre d’abord comment alimenter le Raspberry Pi sur les GPIO. Mise en garde est conseillé, car une tension trop élevée peut détruire le Pi! Si vous ne vous sentez pas en sécurité, choisissez l’alimentation via un câble USB.
Le régulateur de tension L7805 (Fiche technique) peut réduire les tensions de 7 à 25 V à 5 V. 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
Tout d’abord, vous pouvez suivre chaque étape et développer ainsi le code du programme ou, comme décrit à la fin du didacticiel, télécharger le code à partir du référentiel Github puis l’ajuster.
Ce tutoriel doit être aussi personnalisable que possible, car tout le monde a d’autres conditions. Par conséquent, la partie suivante est divisée en différentes sections individuelles. Donc, 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’ajuster en conséquence.
Tout d’abord, cependant, les paramètres des GPIO, 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 |
importation RPi.GPIO comme GPIO importation Adafruit_DHT de MCP3008 importation MCP3008 importation SDL_DS1307 importation temps ################################################## ################ ##################### RÉGLAGES PERSONNALISABLES ###################### ################################################## ################ RÉGLAGES = { « LIGHT_GPIO »: 17, # Numéro GPIO (BCM) pour le relais « LIGHT_FROM »: dix, # à partir de quelle heure la lumière peut être allumée (heure) « LIGHT_UNTIL »: 20, # jusqu’à quelle heure (heure) « LIGHT_CHANNEL »: 0, de MCP3008 « LIGHT_THRESHOLD »: 500, # si le seuil analogique est inférieur à l’un de ceux-ci, la lumière s’allumera « DHT_GPIO »: 27, # Numéro GPIO (BCM) du capteur DHT « DHT_SENSOR »: Adafruit_DHT.DHT22, # DHT11 ou DHT22 « TEMP_THRESHOLD »: 23,0, # à Celcius. Au-dessus de cette valeur, la fenêtre sera ouverte par le servo « SERVO_GPIO »: 22, # Numéro GPIO (BCM), qui ouvre la fenêtre « SERVO_OPEN_ANGLE »: 90,0, # degré, combien le servo ouvrira la fenêtre « LES PLANTES »: [[ { « NOM »: « Tomate », « MOISTURE_CHANNELS »: [[1, 2], de MCP3008 « MOISTURE_THRESHOLD »: 450, # si la valeur analogique moyenne de tous les capteurs est supérieure à ce seuil, la pompe se met en marche « WATER_PUMP_GPIO »: 23, # Numéro GPIO (BCM) pour le Relais « WATERING_TIME »: dix, # Secondes, combien de temps la pompe doit être allumée }, { « NOM »: « Salat », « MOISTURE_CHANNELS »: [[3, 4], « MOISTURE_THRESHOLD »: 450, « WATER_PUMP_GPIO »: 24, « WATERING_TIME »: 12, }, ] } ################################################## ################ ################# FIN DES PARAMÈTRES PERSONNALISABLES ################## ################################################## ################ |
Si vous souhaitez d’autres GPIO ou d’autres paramètres, vous pouvez les régler ici.
Dans les sections suivantes, nous étendons les fonctions (si vous le souhaitez). Vous pouvez trouver le brochage des GPIO sur cette photo.
Préparation pour la serre Raspberry Pi
Avant d’installer les composants électroniques, le cadre froid doit être construit. Vous pouvez placer 2-3 grandes boîtes à fleurs à l’intérieur (selon la taille). Dans ceux-ci, vous pouvez mettre de jeunes plantes ou des graines. Faites attention aux instructions sur l’emballage.
De plus, il est nécessaire de fertiliser le sol. Si vous le souhaitez, vous pouvez également prendre du compost spécial de tomates ou de légumes, qui contient plus de minéraux.
Réglez l’heure
Si le Pi (par exemple après une panne de courant) redémarre, il ne connaît pas l’heure actuelle ni la date, s’il n’y a pas de connexion Internet. Par conséquent, des modules d’horloge en temps réel, dotés d’une batterie, sont utilisés pour stocker en permanence l’horodatage. Cette étape est facultative et peut également être ignorée 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. En règle générale, ces modules renvoient des signaux 5 V, ce qui est trop pour le Raspberry Pi. Alternativement, vous pouvez utiliser un TTL 3,3V-5V.
Commençons par la connexion:
| Module RTC | Tarte aux Raspberry PI |
|---|---|
| SCL | GPIO 3 / SCL (broche 5) |
| SDA | GPIO 2 / SDA (broche 3) |
| VCC / 5V | 5 V (broche 2 ou broche 4) |
| GND | GND (broche 6) ou toute autre broche GND |
Nous chargeons d’abord 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 «Options de localisation», vous pouvez définir votre fuseau horaire. Ensuite, vous pouvez utiliser date pour vérifier si l’heure est correcte. Ouvrez maintenant la console Python (sudo python) et entrez les informations suivantes pour régler l’heure RTC:
import SDL_DS1307 ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68) ds1307.write_now() exit()
Cela enregistre l’heure actuelle.
Nous pouvons maintenant étendre notre script réel (sudo nano greenhouse.py):
|
def Temps de lecture(): essayer: ds1307 = SDL_DS1307.SDL_DS1307(1, 0x68) revenir ds1307.read_datetime() sauf: # alternative: retourne l’heure système: revenir datetime.datetime.utcnow() |
Économisez avec CTRL + O.
Ajuster la luminosité
Sur le côté gauche du MCP3008 se trouvent les 8 canaux qui peuvent lire les valeurs analogiques.
Pour que les plantes reçoivent suffisamment de lumière même par temps nuageux, nous étendons la serre par une LED lumineuse de ~ 20 cm. Vous pouvez également utiliser une bande LED (résistante à l’eau) et l’utiliser comme éclairage supplémentaire. Cependant, l’éclairage artificiel n’est activé que lorsqu’il fait sombre. Par conséquent, nous utilisons un capteur de lumière, qui émet une valeur de luminosité analogique, que nous pouvons lire avec un ADC MCP3008.
Alternativement, il existe également des modules de capteur de lumière qui fournissent déjà une valeur numérique, que la valeur de luminosité soit supérieure / inférieure à une valeur seuil. Si vous voulez l’utiliser, vous devez ajuster légèrement le code.
Le MCP3008 IC dispose de 8 entrées sur lesquelles des signaux analogiques peuvent être lus. Tout d’abord, nous connectons tout:
| Tarte aux Raspberry PI | MCP3008 |
|---|---|
| Broche 1 (3,3 V) | Broche 16 (VDD) |
| Broche 1 (3,3 V) | 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) |
L’un des 8 canaux est utilisé pour le capteur de lumière (canal 0). Nous connectons cela via un résistance de traction 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 prendre la tension 5V directement à partir de là.
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 LED est également connecté au GND de la fiche.
Nous chargeons d’abord 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
Maintenant, nous développons à 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(): horodatage = Temps de lecture()
si RÉGLAGES[[« LIGHT_FROM »] <= horodatage.heure <= RÉGLAGES[[« LIGHT_UNTIL »]: # vérifier les capteurs de lumière adc = MCP3008() # lu 10 fois pour éviter les erreurs de mesure valeur = 0 pour je dans gamme(dix): valeur + = adc.lis( canal = RÉGLAGES[[« LIGHT_CHANNEL »] ) valeur / = 10,0
si valeur <= RÉGLAGES[[« LIGHT_THRESHOLD »]: # allume la lumière GPIO.installer(RÉGLAGES[[« LIGHT_GPIO »], GPIO.EN DEHORS, initiale=GPIO.FAIBLE) # Relais LOW = ON autre: # éteindre la lumière GPIO.installer(RÉGLAGES[[« LIGHT_GPIO »], GPIO.EN DEHORS, initiale=GPIO.HAUTE) autre: # éteindre la lumière GPIO.installer(RÉGLAGES[[« LIGHT_GPIO »], GPIO.EN DEHORS, initiale=GPIO.HAUTE) |
Arrosage automatique
Petite pompe 12V pour irriguer les plantes.
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 via le MCP3008 précédemment connecté.
Étant donné que ces mini-pompes fonctionnent également avec 12V, des relais sont également nécessaires. Dans mon cas, j’ai deux pompes (une par bac à fleurs chacune). Si vous utilisez plus de 3, vous devez choisir une carte relais avec plus de canaux.
Tout d’abord, nous attachons le tuyau à la pompe. À côté du foyer, j’ai mis un seau d’eau (voir les images à la fin). Le tuyau doit être suffisamment long pour aller de ce seau à l’extrémité du bac à fleurs. J’ai scellé l’extrémité du tuyau avec de la colle chaude et j’ai plutôt percé tous les 10 à 15 cm de petits trous dans le tuyau. Lorsque la pression augmente à travers la pompe, les trous doivent être très petits. J’ai utilisé une épaisseur de forage de 1-2 mm.
Ensuite, j’ai attaché le tuyau au bord du bac à fleurs. De l’autre côté d’un trou, j’ai placé un capteur d’humidité du sol. Par la suite, l’humidité moyenne du sol est calculée et décidée 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 ohms.
Si vous utilisez plus de 7 capteurs, vous avez besoin d’un autre ADC MCP3008 (la première place est réservée au capteur de lumière). De plus, chaque capteur est fourni avec 3,3 V 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 l’arrosage des plantes(): # lire l’humidité adc = MCP3008() pour plantObject dans RÉGLAGES[[« LES PLANTES »]: valeur = 0 pour ch dans plantObject[[« MOISTURE_CHANNELS »]: # lu 10 fois pour éviter les erreurs de mesure v = 0 pour je dans gamme(dix): v + = adc.lis( canal = ch ) v / = 10,0 valeur + = v
valeur / = flotte(len(plantObject[[« MOISTURE_CHANNELS »]))
si valeur > plantObject[[« MOISTURE_THRESHOLD »]: # allumer la pompe pendant quelques secondes GPIO.installer(plantObject[[« WATER_PUMP_GPIO »], GPIO.EN DEHORS, initiale=GPIO.FAIBLE) temps.dormir(plantObject[[« WATERING_TIME »]) GPIO.production(plantObject[[« WATER_PUMP_GPIO »], GPIO.HAUTE) |
Ventilation
Selon le foyer ou la serre, il existe plusieurs fenêtres ouvrantes. Pour un lit tôt, il n’y en a généralement pas plus de deux. Pour ouvrir une fenêtre, j’utilise un servo avec un plus long bâton en bois attaché à l’axe. Dans l’état initial, l’angle devrait être de 0 °. Si vous n’êtes pas sûr, vous devez définir le servo une fois par script sur 0 °, puis attacher:
Le servo est fixé à l’intérieur avec du ruban adhésif double face solide.
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 servomoteur est connecté au GPIO 22. Puisque le moteur a probablement besoin de plus de 3,3 V (voir la fiche technique, si vous n’êtes pas sûr), nous le connectons à la tension 5V:
J’ai le capteur DHT simplement fixé au boîtier résistant à l’eau (point suivant). Pour modifier la température à laquelle la trappe doit être ouverte, vous pouvez modifier les paramètres initiaux.
De plus, le code doit être étendu:
|
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 |
def checkWindow(): # lire la température humidité, Température = Adafruit_DHT.read_retry(RÉGLAGES[[« DHT_SENSOR »], RÉGLAGES[[« DHT_GPIO »])
GPIO.installer(RÉGLAGES[[« SERVO_GPIO »], GPIO.EN DEHORS) pwm = GPIO.PWM(RÉGLAGES[[« SERVO_GPIO »], 50)
si Température > RÉGLAGES[[« TEMP_THRESHOLD »]: # fenêtre ouverte angle = flotte(RÉGLAGES[[« SERVO_OPEN_ANGLE »]) / 20,0 + 2,5 pwm.début(angle) autre: # Fermer la fenêtre pwm.début(2,5) # enregistrer le courant temps.dormir(2) pwm.ChangeDutyCycle(0) |
Si vous avez des problèmes de lecture (« ImportError: No module named Raspberry_Pi_Driver« ), Ce message peut vous aider. Alternativement, vous pouvez également utiliser GPIO 4, qui est toujours libre dans mon câblage.
Boîtier étanche et montage
Dans la dernière étape de l’assemblage, nous emballons les éléments de commande importants dans un boîtier résistant à l’eau. Voici le Raspberry Pi ainsi que les relais et tout ce qui est sensible à l’eau à l’intérieur. J’ai percé un trou sur le côté inférieur et tous les câbles qui doivent entrer ou sortir.
De plus, les composants peuvent être soudés à une grille de trous une fois que tout a été testé.
À tout le moins, l’électronique et les connexions potentiellement menacées doivent être tenues à l’écart de l’eau. Il est préférable de choisir une zone couverte.
Activation de la serre Raspberry Pi
Maintenant que nous avons connecté et installé tous les composants, faisons-le fonctionner automatiquement. Pour ce faire, nous étendons le script en appelant les fonctions créées dans l’ordre:
|
138 139 140 141 142 143 144 145 146 147 148 149 |
si __Nom__ == ‘__principale__’: essayer: GPIO.avertissements(Faux) GPIO.mode réglages(GPIO.BCM) # exécuter des fonctions checkLight() l’arrosage des plantes() checkWindow() sauf: GPIO.nettoyer() |
Soit dit en passant: si vous souhaitez télécharger tous les fichiers en même temps, vous pouvez le faire via mon 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, nous enregistrons et revenons au terminal avec CTRL + X.
Soit dit en passant: vous pouvez trouver le chemin absolu d’un répertoire avec cd puis entrer pwd.
Maintenant, vous n’avez plus qu’à attendre. Pour économiser de l’énergie, vous pouvez désactiver le wifi et d’autres services inutiles.
Extensions possibles de la serre Raspberry Pi
Même s’il y en a déjà beaucoup, vous pouvez certainement en ajouter d’autres. J’ai 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 automatiquement les plantes, nous devons cependant verser de l’eau dans le seau. Avec une mesure du niveau de remplissage, nous pourrions envoyer un message par ex. l’application Telegram dès que l’eau doit être remplie. Alternativement, un voyant d’avertissement (LED) peut être installé.
- Mesurer l’humidité: Le capteur DHT11 ou DHT22 peut mesurer l’humidité ainsi que la température. Cependant, nous ne l’utilisons pas pour le moment. Il serait envisageable d’amener l’humidité des pulvérisateurs d’eau à un certain niveau. Cela dépend, bien sûr, des plantes.
- Chaleur: Surtout au printemps ou en automne plus froid, il peut parfois être plus frais. 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 (la fenêtre s’ouvre / se ferme). Grâce à un ventilateur, nous pourrions également refroidir activement à des températures élevées.
- Affichage LCD: En outre, nous pourrions également utiliser un écran LCD afin que nous puissions voir les données actuelles sur un écran.
PS: Vous êtes invités à relier des photos de votre serre ou foyer automatique Raspberry Pi.