Domotiser son poulailler

Finit la corvée d'aller ouvrir et fermer la porte du poulailler tous les jours. Place au confort et à la sécurité en domotisant l'ouverture et la fermeture du poulailler grâce à ESPHome et quelques composants électroniques le tout intégré dans un dashboard percutant et minimaliste.
Domotiser son poulailler
Photo by Danielle-Claude Bélanger / Unsplash

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

Comptez environ une trentaine d'euros pour l'ensemble suivant où vous achetez.

⚠️
Nous aurons donc 2 ESP à programmer : l'ESP8266 pour piloter entre autre le moteur et l'ESP32 Cam (ESP32 avec le module caméra).

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.

Attention : Sur ce schéma le câblage du relais n'est exact que si vous avez un relais 12v. Il sera simplifié si vous avez fait le bon achat : un relais 5v.

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.

💡
Autre solution suivant vos envies, vous pouvez alimenter les deux cartes de la même manière : via le 5v généré par le L298N. Personnellement, les borniers étant petits j'ai décidé de ne pas les surcharger de trop de câbles, mais c'est faisable !

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.

💡
Pro tip : Servez vous d'un niveau à bulle pour vous assurer de la planéité de l'ensemble avant de fixer fermement les éléments.

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.

Home Assistant : vos premiers pas avec ESPHome
Si la domotique vous passionne, il est tentant de créer vos propres objets connectés. C’est ce que propose ESPHome. Cet article permet de comprendre à quoi sert ESPHome, comment l’installer et l’utiliser, ce que sont les micro-contrôleurs ESP32 et ESP8266.

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

output:
  - platform: gpio
    pin: GPIO4
    id: gpio_4

light:
  - platform: binary
    id: relay_ir_light
    output: gpio_4
    name: ${friendly_name} flash

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.

Home Assistant : dialogue avec Telegram
Cet article présente comment intégrer Telegram à Home Assistant et communiquer avec lui. Il est primordial de recevoir des notifications de son système domotique, et d’y accompagner des images ou des vidéos. Et s’il est possible d’y répondre, c’est encore mieux.

Sources

  • Source pour le retrait du filtre IR de la caméra (vidéo)
  • Détails sur le fonctionnement du L298N (lien)