As William would say : “Why not ?”

The spot installed on the front of the garages is kept turned on because the movement sensor is more or less broken. I tried to adjust the small potentimeters but it still malfunction.
As the spot itself is still working I'd rather reuse it. But I never found the sensor as spare parts so it's a perfect excuse to try to DIY something and learn now things. Moreover I'll have to make it weatherproof and that's a fun challenge.

Last but no least, I'll be able to add new functions and make all of that talk with my home automation server!

The bare minimum functions would be :

• sense humans presence near the garage
• sense if it's dark enough to allow to turn on the spot
• being able to turn on and off light(s)
• sends informations to Home Assistant

Cool functions easy to add :

• thermometer and hygrometer to have some local weather informations

If it's really too easy I could also try to add :

• a thermometer in the garage
• a human presence detector in the garage
• being able to turn on and off the lights inside the garage
• control the automated garage doors

But I'll have to think on how to have the sensors and actuators far away from the core of the system.

At first I wanted to buy ready to use zigbee modules. But most of them are running on batteries and I'll probably forget to change them in time. I could make some changes on the devices to add photovoltaic panels but it's hard to keep everything weatherproof.
So I searched other solutions. The simplest one I've found would be a ESPHome based system.
It runs on ESP32, ESP8366 and even RP2040 (with some restrictions on the model) and I can use available breakout boards for compatible sensors and actuators.

Connection to the server would be done over wifi (I'll have to check if house wifi also cover the garage).

What's cool is that the microcontroller can do standalone automation. The connection to home assistant would only serve to get sensor readings, change settings, modify automation or be used as remote for lights.

Another solution would be to use zigbee ready ESP32 like ESP32-C6 (high performances) or ESP32-H2 (low power consumption). It would be a bit more complex but it has the benefit of using the meshed network already deployed in our house. And if done right, it would be able to be used the same as any standard module.

Moreover those ESP32 are also Matter compatible. So it would be possible to flash a new firmware matter compatible.

I used ESPHome's listing to choose the modules. It's mainly based on capabilities described and prices of the modules.

This is a ESP32 Wifi/BLE devboard (it should be compatible with ESPHome).

This is the core of the small home automation installation. Sensors and actuators will be connected with various data bus (I²C, UART, SPI) or on GPIO.

Those boards can often be powered with a large Ces cartes semblent souvent capables de supporter un large panel de tensions en alimentation. Je pense donc l'alimenter via un transfo 230V AC - 12V DC.

Certains modèles possèdent un connecteur ipex permettant d'utiliser une antenne plus imposante que celle intégrée au pcb et surtout permettant de la déporter pour améliorer la réception du signal. Ce genre de modèle me semble plus adapté pour mon usage.

Un capteur LTR390 pour mesurer la luminosité ambiante, ce capteur permet aussi de mesurer le rayonnement UV. C'est grace à lui que le core va pouvoir vérifier si la luminosité ambiante justifie l'allumage du spot extérieur.

Connecté sur le BUS I²C.

Le LD2420 permet non de détecter les mouvements, mais de détecter la présence de trucs qui sont pas là habituellement en utilisant des ondes radios. Il est possible de régler la puissance (donc la distance de détection), la sensibilité ainsi que de calibrer le radar via ESPHome. Comme c'est un détecteur de présence, le timer est moins utile : tant que quelqu'un est détecté dans la zone, la lampe peut rester allumée. Je vais quand même mettre un délais à l'extinction, histoire de ne pas faire guirlande de noël quand on bosse à la bordure de la zone de détection.

Connecté en UART et/ou GPIO qui remonte uniquement si une présence est détectée ou non (mais ne permet pas de toucher aux paramètres, ni la remontée d'infos supplémentaires).

Un capteur BME280 permet de collecter des informations météorologiques. Pas du tout essentiel pour le bon fonctionnement de cette installation, mais le module est assez peu cher. Il me semble donc sympathique d'ajouter ces fonctions pour remonter plus d'infos au serveur Home Assistant.

Connecté en I²C.

Au moins un relais dont la commande puisse se faire en 3.3v et dont les contacts permettent de piloter du 230V. Bien des modules de ce genre sont disponibles sur les différentes plateformes de vente. La plupart sont isolés par des optocoupleurs, ce qui permet de protéger le MCU de tout mauvais fonctionnement de la partie basse tension (230V).

Connecté sur un GPIO.

J'ai acheté “un peu” de matériel pour réaliser plusieurs montages en parallèle et pouvoir les tester sans devoir démonter un pour faire l'autre.

• 5 ESP32 “classiques” avec connecteur antenne ipex
• 1 ESP32-C6 (zigbee)
• 1 ESP32-H2 (zigbee)
• 2 LD2420 (radar)
• 1 LTR390 (lumière)
• 2 BME280 (t°)
• 5 relais avec optocoupleurs
• 2 kits solaires avec un porte li-ion 18650
• 1 DC-DC converter qui accepte 1 à 6V en entrée et sort 3.3V (j'aurais du en prendre 3, mais…)

Ça devrait me permettre de réaliser quelques essais sans trop me prendre le choux.

Autant débuter par un truc simple sans faire non plus dans le simpliste (j'ai pas envie de juste lire/écrire des GPIO), donc récupérer les données d'un capteur de t° et les remonter au central domotique. Si j'arrive déjà à faire ça, ça veut dire que le esp32 parle via I²C au capteur et transmet les valeurs via wifi au serveur domotique. Le tout sera alimenté directement par un chargeur USB, histoire de pas trop se casser les bonbons.

Le plus complexe pour moi, c'est faire le programme. N'ayant jamais utilisé ESPHome, faut le temps d'apprendre quoi mettre dans le code pour obtenir le fonctionnement désiré et comment pousser ce code dans l'ESP32.

Dans un premier temps, je suis passé par l'interface graphique du plugin ESPHome Device Builder de Home Assistant et un pc avec chromium. Ce qui a permis d'assez facilement pousser un premier programme plus ou moins vide dans un ESP32-WROOM-32U surnommé “test001”.

Mais dès que le code s'est étoffé, le raspi s'est retrouvé à bout de souffle pendant la compilation.

Pour soulager ce pauvre raspi il a fallu installer les outils CLI ESPHome sur un “vrai” ordi. Ça prends tout de suite vraiment beaucoup moins de temps pour compiler et je peux pousser le firmware directement par usb dans le core sans passer par un navigateur web.

esphome:
  name: test001
  friendly_name: test001

esp32:
  board: esp32dev
  framework:
    type: arduino
 
# Enable logging
logger:

# Enable Home Assistant API
api:
  encryption:
    key: !secret ota_key

ota:
  - platform: esphome
    password: !secret ota_password

wifi:
  ssid: !secret wifi_ssid
  password: !secret wifi_password
 
  # Enable fallback hotspot (captive portal) in case wifi connection fails
  ap:
    ssid: "Test001 Fallback Hotspot"
    password: !secret fallback_wifi_password

captive_portal:
    
time:
  - platform: homeassistant
    id: homeassistant_time

Ici on a tout le setup de base du module ESPHome, j'y ai ajouté une sync avec l'horloge du serveur. Ça coute rien et ça peut m'éviter des surprises si je prévois des automatismes interne à l'esp basés sur l'heure.

i2c:
  sda: GPIO21
  scl: GPIO22
  scan: true
  id: bus_a

On initialise le bus I²C sur les pins 21 pour SDL et 22 pour SDA et on le désigne par l'identifiant bus_a. Rien de bien folichon.

sensor:
  - platform: bme280_i2c
    address: 0x76
    temperature:
      name: "BME280 Temperature"
    pressure:
      name: "BME280 Pressure"
    humidity:
      name: "BME280 Humidity"

On définit d'abord le type de capteur, ici un BME280.
Ensuite, petite subtilité, mon capteur n'était pas détecté par l'ESP. J'ai poussé un sketch sniffeur d'adresse I²C sur un arduino. Il m'a signalé qu'un truc répondait à l'adresse 0x76 après avoir câblé le capteur dessus. Évidemment, l'adresse par défaut pour ces capteurs dans ESPHome est 0x77, ça ne risquait pas de fonctionner. Après avoir spécifié l'adresse, on obtient bien les remontées de valeurs du capteurs.
Puis les différentes valeurs à remonter au serveur et le nom sous lequel les afficher. J'ai laissé les noms par défauts donnés sur le site ESPHome parce que c'est avant tout un proto, il n'est pas destiné à être utilisé tel quel.

C'est très simple de câbler un capteur I²C sur le core, seuls 4 fils suffisent :

• GND sur GND
• 3.3V sur 3.3V
• SDA sur gpio 21
• SCL sur gpio 22

Dans un premier temps je n'avais que ça :

Après avoir corrigé l'adresse dans le firmware :

C'est officiellement un grand succès!

Il va être nécessaire d'étalonner les capteurs lorsque le module complet sera installé à sa place définitive. Parce que si la pression semble correcte (par rapport à mes autres capteurs et météo France), la température et l'humidité paraissent douteuses. Le capteur zigbee du commerce et un petit thermomètre hygromètre de table dans la même pièce donnent des relevés très similaires entre-eux, mais ces relevés sont différents de ceux de test001 (genre 10% d'humidité en plus et 1 ou 2 degrés en moins).

Ajouter le capteur lumière et UV est vraiment trivial. Le bus I²C est déjà initialisé, il y a juste à brancher les quatre pins du capteurs sur les mêmes pins du core que le BME280. Et niveau code, c'est pas plus compliqué que pour le BME on rajoute ça dans la section “sensor” :

  - platform: ltr390
    uv_index:
      name: "UV Index"
    uv:
      name: "UV Sensor Counts"
    light:
      name: "Light"
    ambient_light:
      name: "Light Sensor Counts"

Et ça fonctionne directement.

Le radar à ondes millimétriques est assez simple à raccorder physiquement, encore une fois 4 fils suffisent :

• 3.3V sur 3.3V
• GND sur GND
• RX sur TX0 coté ESP
• OT2 ou OT1 (en fonction de la version de firmware) sur RX0 coté ESP

Si on rajoute un cinquième fil, on peut avoir le retour sur GPIO de la présence détectée ou non et éventuellement pouvoir utiliser des modes plus économes en énergie sur l'ESP avec le GPIO qui vient le réveiller. Dans mon cas, pas très utile, le montage ne tournant pas sur batterie.

Il faut d'abord configurer le bus UART qu'on va exploiter.

uart:
  tx_pin: GPIO01
  rx_pin: GPIO03
  baud_rate: 115200

Ensuite, le code pour le module n'est pas extrêmement complexe (c'est principalement attribuer à des variables d'entrés ou de sorties des noms), mais il expose plus d'interfaces que nos autres capteurs, principalement pour configurer le radar et récupérer les données du radar.

ld2420:

text_sensor:
  - platform: ld2420
    fw_version:
      name: LD2420 Firmware

sensor:
  - platform: ld2420
    moving_distance:
      name : Moving Distance

binary_sensor:
  - platform: ld2420
    has_target:
      name: Presence

select:
  - platform: ld2420
    operating_mode:
      name: Operating Mode
number:
  - platform: ld2420
    presence_timeout:
      name: Detection Presence Timeout
    min_gate_distance:
      name: Detection Gate Minimum
    max_gate_distance:
      name: Detection Gate Maximum

    gate_select:
      name: Select Gate to Set
    still_threshold:
      name: Set Still Threshold Value
    move_threshold:
      name: Set Move Threshold Value

    gate_move_sensitivity:
      name: Move Calibration Sensitivity Factor
    gate_still_sensitivity:
      name: Still Calibration Sensitivity Factor

Ouais, pour tester et comparer le rapport emmerdement/bénéfices. J'aimerais aussi beaucoup pouvoir comparer la couverture réseau entre les deux. Surtout que sous peu, quelques modules zigbee supplémentaires devraient être installés dans la maison.