Sommaire
Personnellement, mon poulailler est au fond du jardin qui se trouve en contrebas de ma maison. C'est une corvée d'aller fermer / ouvrir la porte tous les jours, à tel point qu'on ne le faisait plus. Puis, la domotique a frappé à la porte avec de forts arguments. Me voilà donc à domotiser la porte de mon poulailler afin d'accroître la sécurité de mes poulettes et d'avoir le confort que ça se fasse tout seul. Puis, il faut l'admettre, ce projet est aussi une bonne raison pour bricoler.
Cahier des charges
- Intégré dans Home Assistant
- Pouvoir voir les poules et les œufs grâce à une caméra, même en conditions de faible éclairage
- Monitorer la température et l’humidité
- Connaître l’état de la porte à tout moment
- Que la porte s’ouvre automatiquement au lever du soleil et se referme au coucher du soleil
- Pouvoir contrôler manuellement l’ouverture ou la fermeture de la porte
Matériel nécessaire
- Une carte type ESP8266 avec WiFi intégré
- Une carte pour piloter le moteur, type pont en H (L298N)
- Un relais 5V
- Une carte ESP32 Cam en guise de caméra
- Une source lumineuse infrarouge (IR led ring)
- Une carte DHT22 pour récupérer la température et l’humidité
- Des capteurs de fin de course
- Du câble téléphonique PTT
- Un moteur électrique 12V
- Une courroie
- Des poulies
- Une poulie d’entrainement moteur
- Une barre en cuivre (1m, Ø12)
- Un transformateur secteur 230v - 12v
- Câbles et divers accessoires propres à chacun concernant la conception de la porte
- Quelques pièces imprimées en 3D
Comptez environ une trentaine d'euros pour l'ensemble suivant où vous achetez.
Modélisations
Modélisation du poulailler
Avant toute chose, modélisons ! C'est important pour éviter les allers-retours de prise de cote et dimensions. Je le rappelle, mon poulailler est loin de ma maison !
Le poulailler, parlons en : c'est une construction maison qui consiste en deux palettes européennes posées l’une contre l’autre et surélevées sur parpaings. La structure est composée de tasseaux de sapin (30 x 40mm) et le bardage est construit à partir de planches de palettes. L’ensemble est terminé par un toit de tôle et une gouttière pour récupérer l’eau de pluie.
Je modélise donc tout ça sur Fusion 360 afin d’avoir une idée du placement des différents éléments par la suite.
Une fois le poulailler modélisé et à l’échelle, j’imagine le système de glissière sur lequel viendra coulisser la porte. J’en profite également pour décider de la manière dont la courroie sera fixée aux coulisseaux, le tout dans l’objectif d’avoir précisément le dessin des pièces qui seront ensuite imprimées en 3D.
Les coulisseaux sont les pièces fixées à la porte et permettent à la barre en cuivre de coulisser. On distingue une fente et un trou sur le dessus. La fente laisse passer une extrémité de la courroie et le trou au-dessus permet d’insérer un écrou qui sera collé.
Je peux dès lors venir serrer fermement la courroie avec une vis qui s’insère dans l’écrou. Cela me permet de facilement démonter le système si nécessaire et d’ajuster facilement la tension de la courroie.
Modélisation du boitier à composants
Il faut aussi imaginer le boitier qui recevra la collection de fils et les composants électroniques sélectionnés.
Vous pouvez très bien le fabriquer dans le matériau de votre choix. Personnellement, j'affectionne le PLA de mon imprimante 3D. Je modélise donc un boitier sur mesure en y incluant directement les composants aux bonnes dimensions.
Une boite simple, de 15 cm de côtés me donnant de l'espace pour plaquer les câbles le long des parois. Deux trous percés pour l'arrivée du 12v du transformateur et pour les câbles qui ressortent de la boite en direction du poulailler (caméra, moteur, ESP32 etc ..)
Je percerai par la suite 2 à 4 trous dans le fond de la boite pour l'accrocher au mur.
Électronique
La partie électronique peut paraître un peu compliquée, mais cela reste largement abordable. Je n’utilise que 3 cartes électroniques différentes et 2 modules ESP (ESP8266 / ESP 32 cam)
Voyons en détails à quoi sert chaque carte.
Caméra (ESP32 cam)
Le poulailler est sombre par nature et c’est surtout à la nuit tombée que je souhaite vérifier si toutes les poules sont bien rentrées. J’ai donc décidé de rendre l’ESP32 Caméra sensible aux infrarouges. Pour ça, il suffit de dévisser l’objectif et d’y retirer le filtre IR qui s’y trouve.
Il faut maintenant s’occuper de la gestion de la lumière infrarouge. On ne peut pas simplement se contenter de laisser la lumière IR allumée constamment. D’une part ça consomme de l’énergie inutilement et d’autre part, les poules semblent être capables de percevoir cette lumière. Inutile de les déranger toute la nuit alors que personne ne les regarde.
L’objectif est donc d’allumer la lumière infrarouge uniquement lorsque la caméra est utilisée. Le code ESPHome qui s’exécute sur l’ESP32 cam nous permet de faire facilement cela grâce aux fonctions on_stream_start et on_stream_stop.
Plus de détails dans la suite de l’article...
Module L298N
Cette carte nous permet de piloter jusqu’à deux moteurs à partir d’ordres envoyés depuis une puce électronique. Typiquement, les puces équipant nos cartes ESP peuvent contrôler la vitesse et le sens de rotation de moteurs électriques bien trop puissants pour être connectés directement à leurs bornes.
Je me sers également de cette carte comme convertisseur 12v -> 5v me permettant d’alimenter l’ESP 32.
Plus de détails dans le schéma de câblage qui suit.
Relais 5V
Le relais est une carte électronique dont le comportement s’apparente au L298N dans la mesure où il nous permet également d’actionner des appareils fonctionnant sur des tensions plus élevées que ce que nous fournit notre circuit de commande.
Typiquement, grâce au relais, je vais pouvoir envoyer un signal de 3,3v qui fermera un circuit (dit de puissance) pour alimenter les LEDs Infrarouges qui nécessitent 12v.
Sonde de température DHT22
La sonde de température et d'humidité DHT22 est très simple à connecter. Je vous conseille la version avec résistances intégrées, ça facilite son utilisation.
On y trouve 3 pins : une entrée pour le 5v (VCC), la masse (GND) et les données (DAT).
Schéma complet
Voici la vue d'ensemble du schéma de câblage avec tous les éléments du projet.
On démarre de la gauche : L'arrivée du 12v grâce au transformateur branché sur secteur. De là, on vient alimenter la carte L298N sur ses bornes 12v. On en profite, il nous ressort du 5v : alimentons notre ESP8266 ! Pour ça, j'utilise un câble USB, ça me permettra de récupérer du 5v sur la borne Vin. On branche les capteurs magnétiques sur les entrées D1 et D2 et on vient brancher les bornes D5 et D6 à la carte L298N pour piloter le moteur dans un sens ou dans l'autre.
Dernière étape sur cette carte : la sortie de puissance. On vient tirer deux câbles qui vont rejoindre le moteur. C'est par ici que sera redirigé le 12v du transformateur vers le moteur.
Hop ! On repart du 12v originel et on vient alimenter notre relais 12v maintenant.
Spécificité pour ceux qui ont un relais 12v à la place d'un relais 5v, on shinte l'entrée DC+ et com. Maintenant, on vient brancher la lampe infrarouge qui se connecte sur l'entrée NO du relais. Cette entrée est Normalement Open ce qui signifie que le circuit est ouvert (donc non alimenté) par défaut et qu'il sera Closed (fermé donc alimenté) une fois le relais actionné.
Dernière étape, l'ESP32 caméra. On repart de l'ESP8266 et on vient les connecter tous les deux via les pins Vin et Gnd de l'ESP8266. C'est lui qui nous fournit le 5v nécessaire à l'alimentation de cette carte.
Et enfin, on vient connecter la sonde de température aux pins 3.3v et Gnd de l'ESP32 cam et au GPIO15.
Ne pas oublier de connecter le GPIO2 au relais sur la borne IN. C'est également la carte ESP32 cam qui actionnera le relais.
Voilà, tout est connecté. Place à l'installation physique des éléments.
Conception
Il faut désormais placer les poulies, la courroie, le moteur ainsi que la caméra et les capteurs, sur votre poulailler. Ici, c'est propre à chacun et il n'y a pas de modèle à suivre. Laissez votre imagination décider.
Porte du poulailler
J'ai découpé un morceau de métal aux bonnes dimensions dans un reste qui trainait chez moi. C'est ce qui sera la porte du poulailler.
Elle est maintenue en place sur les coulisseaux avec 4 vis. Les coulisseaux viennent glisser sur un tube en cuivre préalablement graissé à la graisse de vaseline. Il faut qu'il y ait le moins de frottement et que la barre soit la plus droite possible afin que le moteur n'ait pas trop à forcer pour déplacer le tout.
La barre est ensuite insérée dans les attaches qui sont elles, fixées au poulailler à l'aide de 2 vis. La barre devient ainsi fixe et seule la porte viendra coulisser dessus.
Il reste maintenant à installer la courroie, les différentes poulies et le moteur. J'ai choisi ce type d'installation qui m'assure un maximum de contact entre la courroie et les poulies : plus il y a de matière en contact meilleur sera le transfert d'énergie et moins la courroie "sautera" de crans.
On distingue par la même occasion les capteurs magnétiques. Un à chaque bout de la course de la porte. Je n'utilise qu'un seul aimant détecteur sur la porte pour deux capteurs sur le poulailler, mais il est tout à fait possible d'utiliser un capteur et son déclencheur à chaque fois. C'est par pur goût esthétique que j'ai choisi d'en utiliser qu'un seul.
La photo montre un coulisseau avec la vis de maintien de la courroie qui passe à l'intérieur. Ainsi, je peux facilement démonter le système et/ou ajuster la tension de la courroie si nécessaire.
Les poulies sont alignées le plus possible avec la barre pour que la courroie soit dans le même axe. Ça évite qu'elle ne sorte des poulies et facilite, là encore, le transfert d'énergie.
Sur cette photo, on distingue le moteur et sa poulie particulière. Elle est directement fixée sur l'arbre du moteur à l'aide de deux petites vis qu'on vient fermement serrer. La courroie descend ensuite sur deux poulies non crantées qui participent à la tension de l'ensemble du système.
L'installation de ces éléments a été laborieuse et beaucoup d'aller et retour ont été nécessaire afin d'avoir quelque chose de fonctionnel et durable. Prenez votre temps et éprouvez le système avant de tout fixer de manière plus ou moins permanente, car les éléments physiques sont sujets aux variations de températures, de la météo et du temps qui passe.
Caméra, température et lumière infrarouge
La caméra a été installée dans un boitier imprimé en 3D. Ce boitier me permet de passer tous les fils dans sa structure ce qui est pratique, mais m'empêche d'utiliser des fils Dupont : soudure obligée sinon le boitier ne se referme pas.
Malgré cela, il reste très pratique car inclinable sur deux axes (horizontalement et verticalement) ce qui est un vrai plus pour donner le bon angle de vue dans le poulailler.
J'ai modifié le boitier une fois l'impression terminée pour y clipser les lampes infrarouges et y ai percé quelques trous à l'arrière pour y fixer la carte DHT22. Le tout forme un ensemble compact et pratique, facilement démontable si besoin et avec peu de câbles visibles. L'installation actuelle n'est pas forcément représentative de l'installation finale, mais ça vous donne une idée !
Intégration Home Assistant
Nous utilisons ESPHome qui fera le lien entre les cartes ESP et Home Assistant. Pour plus d'informations, se référer à cet article.
Argonaute
ESP8266 et contrôle du moteur
Le code ESPHome pour le pilotage du moteur doit correspondre à ce scénario :
La porte s'ouvre tous les matins au lever du soleil jusqu'à ce qu'elle rencontre le capteur magnétique d'ouverture qui arrête le déplacement de la porte.
Une demi-heure après le coucher du soleil, la porte se ferme jusqu'à la détection de l'autre capteur magnétique qui arrête également le déplacement de la porte.
Voici le code dont je vais détailler certaines portions.
esphome:
name: poulailler
friendly_name: Poulailler
substitutions:
friendly_name: Poulailler
esp8266:
board: esp01_1m
# Enable logging
logger:
# Enable Home Assistant API
api:
encryption:
key: !secret api_encryption_key_poulailler
ota:
password: !secret ota_password_poulailler
wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password
captive_portal:
time:
- platform: homeassistant
sun:
latitude: 48.866
longitude: 2.333
on_sunrise:
- then:
- cover.open: porte_poulailler
on_sunset:
- then:
- delay: 30min
- cover.close: porte_poulailler
binary_sensor:
- platform: gpio
pin:
number: GPIO5
mode: INPUT_PULLUP
inverted: True
id: porte_ouverte
name: "Porte ouverte"
- platform: gpio
pin:
number: GPIO4
mode: INPUT_PULLUP
inverted: True
id: porte_fermee
name: "Porte fermée"
sensor:
- platform: wifi_signal
name: ${friendly_name} Wifi signal
id: wifi_signal_db
update_interval: 60s
entity_category: "diagnostic"
- platform: copy # Reports the WiFi signal strength in %
source_id: wifi_signal_db
name: "WiFi Signal Percent"
filters:
- lambda: return min(max(2 * (x + 100.0), 0.0), 100.0);
unit_of_measurement: "%"
entity_category: "diagnostic"
device_class: ""
- platform: uptime
name: ${friendly_name} Uptime
switch:
- platform: gpio
pin: GPIO14
inverted: True
name: "Moteur relais 1"
id: moteur_relais_1
internal: True
- platform: gpio
pin: GPIO12
inverted: True
name: "Moteur relais 2"
id: moteur_relais_2
internal: True
- platform: restart
name: ${friendly_name} restart
cover:
- platform: endstop
name: "Porte Poulailler"
id: porte_poulailler
open_action:
- switch.turn_on: moteur_relais_2
- switch.turn_off: moteur_relais_1
open_duration: 14s
open_endstop: porte_ouverte
close_action:
- switch.turn_off: moteur_relais_2
- switch.turn_on: moteur_relais_1
close_duration: 14s
close_endstop: porte_fermee
stop_action:
- switch.turn_off: moteur_relais_1
- switch.turn_off: moteur_relais_2
text_sensor:
- platform: version
name: ${friendly_name} ESPHome Version
- platform: wifi_info
ssid:
name: ${friendly_name} WiFi
La ligne 39 qui commence par sun permet de spécifier notre emplacement géographique avec la longitude et la latitude. Ces informations permettent de connaître précisément l'heure à laquelle le soleil se lève et se couche. Les lignes suivantes décrivent le comportement au lever et au coucher du soleil. On voit qu'il y a un délai de 30 minutes lors de la fermeture, on s'assure que les poules sont bien toutes rentrées à temps !
On définit ensuite 2 capteurs binaires. Cela correspond aux états des capteurs d'ouverture et de fermeture de la porte.
Viennent ensuite quelques lignes de diagnostics WiFi puis enfin les switchs. On en a deux qui contrôlent chacun un sens de rotation du moteur. Ils sont spécifiés comme étant "internal" et ainsi, ils ne seront pas contrôlables depuis Home Assistant. Par contre, on définit par la suite un "cover" qui peut se traduire comme un volet roulant. C'est un peu ce qu'on met en place finalement : une porte coulissante qui a deux fins de courses et peut s'arrêter à mi-chemin si on le souhaite. La nôtre se déplace horizontalement alors qu'un volet roulant se déplace verticalement, c'est la seule différence.
Les actions du "cover" vont remonter dans Home Assistant, on y définit donc trois actions "open_action", "close_action" et "stop_action". Quand on ouvre la porte, on souhaite démarrer le moteur dans un sens de rotation et l'arrêter dans l'autre. Ce sera l'inverse pour l'action de fermeture. Et enfin l'action de stop premettra de tout arrêter.
On peut également spécifier une durée d'ouverture et fermeture (à chronométrer sur place) pour pouvoir, depuis Home Assistant, spécifier via une barre coulissante, la position exacte souhaitée de la porte. Peu utile dans notre cas de figure.
Les lignes importantes sont celles qui définissent les conditions d'arrêt automatique du déplacement de la porte. Pour l'ouverture, c'est la ligne contenant open_endstop et pour la fermeture, c'est celle commençant par close_endstop.
Ces lignes indiquent qu'on doit arrêter le fonctionnement du moteur lorsque les binary_sensor porte_fermee ou porte_ouverte sont détectés. Le cœur de l'automatisation se situe sur ces lignes.
Une fois le code ESPHome chargé, les entités suivantes vont remonter dans Home Assistant.
Vous avez des actions pour ouvrir, stopper ou fermer la porte ; En dessous, l’état de vos capteurs de fin de course, ce qui nous renseigne sur l’état actuel de la porte ; Puis un bouton pour redémarrer l’ESP et enfin quelques données de diagnostic sur la connexion.
ESP32 Cam et contrôle de la lumière
L’ESP32 Cam est un ESP32 qui contient une caméra. Ceci étant dit, on peut y ajouter des capteurs comme n’importe quelle carte ESP32. C’est donc à cette carte que j'ai connecté mon capteur de température, pour avoir une remontée d’informations au plus proche de la réalité : dans le poulailler directement.
La caméra est insérée dans un boitier imprimé en 3D sur lequel j'ai fixé la lumière et la carte DHT22 est elle-même fixée derrière le boîtier de la caméra. Les fils passent dans le boitier en lui-même ce qui participe au câble management dans le poulailler et il est possible de l'orienter horizontalement et verticalement : idéal pour avoir l'inclinaison parfaite pour voir au mieux nos petites poulettes.
Voici un aperçu de ce que donne l'utilisation de la lumière infrarouge avec le filtre IR de la caméra retiré. À gauche une capture de ce que voit la caméra en fin de journée sans lumière infrarouge activée. A droite, la même image, mais avec la lumière.
Comme je vous le disais tout à l'heure, c'est l'ESP32 qui a à charge d'allumer et d'éteindre la lumière infrarouge. Pour ce faire, on va s'aider de l'API d'ESPHome et quand on recherche la définition de esp32_camera, on trouve les méthodes on_stream_start et on_stream_stop. Grâce à ça on est en mesure de réaliser des actions lorsque quelqu'un regarde la caméra et lorsque celle-ci est "relâchée".
Sur cet extrait de code, on voit que lorsque le stream démarre, je viens mettre à jour un capteur côté Home Assistant pour m'indiquer que quelqu'un regarde la caméra et je viens également actionner le relais qui contrôle les lampes infrarouges. La même chose inversée lorsque le stream s'arrête.
Voici le code ESPHome complet de la partie caméra.
esphome:
name: poulcam
friendly_name: Poulcam
substitutions:
friendly_name: Poulcam
esp32:
board: esp32dev
framework:
type: arduino
# Enable logging
logger:
# Enable Home Assistant API
api:
encryption:
key: !secret api_encryption_key_poulcam
ota:
password: !secret ota_password_poulcam
wifi:
ssid: !secret wifi_ssid
password: !secret wifi_password
# Enable fallback hotspot (captive portal) in case wifi connection fails
ap:
ssid: "Poulcam Fallback Hotspot"
password: "Hm16a313DSWf"
captive_portal:
esp32_camera:
external_clock:
pin: GPIO0
frequency: 20MHz
i2c_pins:
sda: GPIO26
scl: GPIO27
data_pins: [GPIO5, GPIO18, GPIO19, GPIO21, GPIO36, GPIO39, GPIO34, GPIO35]
vsync_pin: GPIO25
href_pin: GPIO23
pixel_clock_pin: GPIO22
power_down_pin: GPIO32
# Image settings
name: Poulcam
on_stream_start:
- lambda: 'id(cam_streaming).publish_state(true);'
- switch.turn_on: relay_ir_light
on_stream_stop:
- lambda: 'id(cam_streaming).publish_state(false);'
- switch.turn_off: relay_ir_light
max_framerate: 25 fps # default: 10 fps, max 60
idle_framerate: 0.2 fps # default: 0.1 fps - framerate for 'picture' in HA dashboard
resolution: 1024x768
jpeg_quality: 10
vertical_flip: true
horizontal_mirror: true
contrast: 0 # default: 0, variable -2 to 2
brightness: 1 # default: 0, variable -2 to 2
saturation: 0 # default: 0, variable -2 to 2
# Server video/pictures, https://esphome.io/components/esp32_camera_web_server.html
esp32_camera_web_server:
- port: 8080
mode: stream
- port: 8081
mode: snapshot
time:
- platform: homeassistant
id: homeassistant_time
sensor:
- platform: wifi_signal
name: ${friendly_name} Wifi signal
id: wifi_signal_db
update_interval: 60s
entity_category: "diagnostic"
- platform: copy # Reports the WiFi signal strength in %
source_id: wifi_signal_db
name: "WiFi Signal Percent"
filters:
- lambda: return min(max(2 * (x + 100.0), 0.0), 100.0);
unit_of_measurement: "%"
entity_category: "diagnostic"
device_class: ""
- platform: uptime
name: ${friendly_name} Uptime
- platform: dht
model: dht22
pin: GPIO15
temperature:
name: ${friendly_name} Température
humidity:
name: ${friendly_name} Humidité
update_interval: 60s
- platform: internal_temperature
name: "Température Processeur"
text_sensor:
- platform: version
name: ${friendly_name} ESPHome Version
- platform: wifi_info
ssid:
name: ${friendly_name} WiFi
switch:
- platform: restart
name: ${friendly_name} restart
- platform: gpio
name: "IR Light Switch"
id: relay_ir_light
pin:
number: GPIO2
inverted: False
binary_sensor:
- platform: template
name: "Camera is streaming"
id: cam_streaming
On retrouve au début l'initialisation des informations de la caméra sur la carte. On peut également retourner horizontalement / verticalement l'image si nécessaire ainsi qu'augmenter ou diminuer le contraste et la luminosité. On retrouve l'extrait de code de tout à l'heure qui définit les actions à réaliser lorsque le stream est démarré ou arrêté.
Un peu plus bas, on a la définition de la carte DHT22 qui nous remonte les informations de température et d'humidité toutes les minutes. Et enfin, dans la partie switch, on a un bouton nous permettant d'activer ou non la lumière infrarouge. Vous pourriez le spécifier comme étant "internal" pour qu'il ne remonte pas dans Home Assistant, car il est automatiquement activé / désactivé sur les actions de on_stream_start et on_stream_stop
Sur Home Assistant, on retrouve donc les informations suivantes :
On y trouve un contrôle du flash intégré de l'ESP32 cam. Personnellement, je ne m'en sers pas car elle est de toute façon bloquée par le support des lampes infrarouges et sa puissance est trop faible pour éclairer correctement l'intérieur du poulailler.
Ensuite, place aux capteurs : on retrouve le fameux booléen sur l'état du stream (quelqu'un regarde ou non). Puis la caméra en elle-même. Appuyer dessus lancera le stream. N'oublions pas les informations de la sonde DHT22 : la température et l'humidité.
Et enfin, la possibilité de redémarrer l'ESP et quelques informations de diagnostics WiFi.
Dashboard
Place à votre imagination pour intégrer au mieux toutes les informations et les contrôles que vous avez maintenant. J'ai opté pour un dashboard simple. Rien de compliqué.
Mais je travaille sur une intégration un peu plus poussée via les fonctionnalités de HA Floorplan dont voici un petit aperçu.
Conclusion
Vous voilà avec un poulailler domotisé. Finit la corvée d'aller leur ouvrir et de retourner fermer la porte dans la pluie et le vent en hiver et tard le soir ou (trop) tôt le matin en été.
Les possibilités d'améliorations sont nombreuses sur ce type de projet. Vous pourriez par exemple décider d'ajouter la fonctionnalité d'envoi d'une photo lorsque la porte s'est fermée le soir afin d'être certain que toutes les poules sont bien rentrées. Et si la porte n'est pas bien ouverte ou fermée, envoyer un message d'alerte.
L'article suivant décrit comment envoyer un message et une éventuelle photo avec Telegram.
Argonaute
