Home Assistant Intégration du compteur Geiger : 8 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Dans ce didacticiel, je vais vous montrer comment ajouter des capteurs personnalisés à HASS (assistant domestique), plus précisément à un compteur Geiger, mais le processus est également similaire pour les autres capteurs.

Nous utiliserons la carte NodeMCU, un compteur Geiger basé sur Arduino et un assistant domestique déjà installé.

L'intégration sera basée sur un serveur MQTT (public ou privé) et je vais vous guider pas à pas avec cela.

Si vous ne savez pas ce qu'est home-assistant, veuillez visiter leur page https://www.home-assistant.io/. C'est une plate-forme domotique bien connue, très bien entretenue et hautement personnalisable.

Vous apprendrez:

- configuration avancée pour Home Assistant

- NodeMCU (carte de développement) et comment le programmer avec l'IDE Arduino

- OTA (mises à jour en direct) utilisant l'IDE Arduino pour la carte NodeMCU

- comment connecter un périphérique série au NodeMCU

- installer manuellement un serveur MQTT sur linux (facultatif)

Hypothèses de base:

- vous avez Home Assistant opérationnel

- vous connaissez un peu l'électronique

- vous avez Arduino IDE installé

Étape 1: Pièces et outils

Les pièces:

1. Carte NodeMCU

2. planche à pain

3. fils juper mâle-mâle et mâle-femelle

3. câble usb vers micro usb

4. compteur arduino geiger avec interface série

(recherchez sur Ebay "arduino geiger couter")

5. matière radioactive (facultatif un petit échantillon d'essai)

Outils:

1. IDE Arduino

2. Home Assistant installé

Étape 2: Principe de travail

Notre objectif est d'afficher sur HomeAssistat (HASS) les lectures du compteur Geiger. D'un côté, nous avons un serveur HASS opérationnel quelque part, il peut s'agir d'un Raspberry Pi ou d'un autre appareil et de l'autre côté, nous avons le compteur Geiger.

Le compteur geiger possède un port série, une solution sera de rattacher directement le port série au RaspberryPi sur lequel tourne le HASS.

Quelques raisons pour lesquelles ce n'est peut-être pas une bonne idée:

- il n'y a pas d'espace physique là-bas

- nous avons un autre périphérique sur le port série

- nous voulons attacher un capteur environnemental qui devrait être placé à l'extérieur au lieu du compteur geiger

Ok donc nous allons explorer une autre possibilité de faire la connexion via WIFI:

Le HASS prend en charge la lecture des données des capteurs et l'affichage via un serveur MQTT, ce type de serveur est une connexion légère pour les petits appareils, un appareil publie un message sur un "sujet" l'autre écoute sur ce sujet pour recevoir le message. Donc HASS écoutera, et nous avons besoin de quelque chose qui publiera le message.

Notre capteur ne sait parler que sur la ligne série, nous utiliserons donc une carte qui peut lire une ligne série et qui peut se connecter via WIFI et parler au serveur MQTT. Une carte bon marché qui fait cela est le NodeMCU.

Le NodeMCU peut être programmé avec Arduino IDE. Le croquis est assez simple, il fait ce qui suit:

- se connecte au WIFI

- maintient une connexion MQTT avec le serveur et réessaye la connexion en cas d'échec ou de déconnexion

- écoute les données entrantes en série comme une série d'entiers

- une fois qu'un entier arrive, il l'envoie via MQTT à un sujet spécifique

Étape 3: Assembler l'appareil

Nous utiliserons des maquettes et des fils donc c'est assez simple, nous avons quelques étapes:

- mettre le NodeMCU sur la maquette

- connecter le tube geiger au compteur geiger (attention à la polarité)

- VIN va au compteur Geiger +

- GND va au compteur Geiger -

- NodeMCU D7 (broche 13) va à Geiger TX

- NodeMCU D8 (broche 15) va à Geiger RX

- alimenter NodeMCU via micro USB depuis l'ordinateur

Étape 4: Téléchargez le code

Nous allons utiliser Arduino IDE et nous nous assurerons que la carte NodeMCU est installée et que la bibliothèque Adafruit_MQTT est installée.

1. Clonez le référentiel github: https://github.com/danionescu0/arduino et copiez le croquis de projects/HASSGeigerIntegration vers l'emplacement de votre carnet de croquis arduino

2. Ouvrez Arduino IDE et installez NodeMCU

- allez dans Fichier -> Préférences, dans les URL du gestionnaire de cartes supplémentaires, ajoutez https://arduino.esp8266.com/stable/package_esp8266com_index.json si vous avez déjà quelque chose, mettez une virgule devant et cliquez sur ok

- dans Outils -> Carte -> Gestionnaire de cartes, tapez "nodemcu" et sélectionnez l'entrée esp8266 par ESP8266 Community, puis appuyez sur installer

3. Installez Adafruit_MQTT

- allez dans Outils -> Gérer les bibliothèques -> recherchez "Adafruit_MQTT" et installez "Bibliothèque Arduino MQTT"

4. Branchez le câble USB sur votre ordinateur et configurez la carte:

- allez dans Outils -> Carte -> sélectionnez NodeMcu 1.0

- Outils -> Port -> votre port USB

- laisser les autres paramètres inchangés

4. Dans l'esquisse, modifiez vos identifiants WIFI pour qu'ils correspondent aux vôtres:

#define STASSID "ssid" // Remplacez par votre WIFI SSID

#define STAPSK "pass" // Remplacez par votre mot de passe WIFI

5. Téléchargez le croquis sur votre tableau et après le téléchargement, réinitialisez le tableau à partir du bouton

6. Ouvrez le moniteur série, si tout s'est bien passé, vous devriez voir une sortie comme celle-ci:

Démarrage

Adresse IP: 192.168.1.168 OTA activé Connexion à MQTT… MQTT Connecté ! {"rayonnement": 0,03}..

Étape 5: Configurer HomeAssistant

Nous allons supposer que vous avez un assistant domestique opérationnel. Sur mon système, j'ai HASSOS version 3.12 sur un RaspberryPi. Si votre version d'assistant domestique est trop ancienne ou très récente, certaines fonctionnalités peuvent différer. Ce tutoriel fonctionne à coup sûr avec la version 3.12.

Si vous n'avez pas installé Home Assistant, consultez leur guide d'installation officiel:

Avant de poursuivre l'installation, assurez-vous que le NodeMCU est branché et qu'il publie les données.

Ok, nous aurons ici aussi une série d'étapes pour la configuration:

1. Installez "file editor" si vous ne l'avez pas dans le menu, voici le tuto officiel:

2. Modifiez le fichier "/config/configuration.yaml" et ajoutez ce qui suit et enregistrez-le

- la section mqtt si vous ne l'avez pas déjà

mqtt:

courtier: broker.hivemq.com découverte: true discovery_prefix: ha

- la section capteurs

capteur:

- plate-forme: mqtt name: "Radiation" state_topic: "ha/radiation" unit_of_measurement: 'uSv' unique_id: "radiation" value_template: "{{ value_json.radiation }}"

3. Dans Configuration -> Contrôles du serveur: appuyez sur "Vérifier la configuration", vérifiez le fichier de configuration yaml pour les erreurs, puis appuyez sur "redémarrer" et attendez qu'il soit redémarré

4. Depuis Présentation -> Menu du coin supérieur droit -> Configurer l'interface utilisateur -> appuyez sur le bouton + en bas à droite

5. Sélectionnez "sensor" dans la liste -> dans le champ "entity" recherchez "sensor.radiation", dans le champ du nom écrivez "Radiation" et cliquez sur ok, il devrait être sur la page principale maintenant

Étape 6: Configuration de votre propre serveur MQTT [Facultatif]

Parlons un peu de MQTT

« MQTT est un protocole de transport de messagerie de publication/abonnement client-serveur. Il est léger, ouvert, simple et conçu pour être facile à mettre en œuvre. Ces caractéristiques le rendent idéal pour une utilisation dans de nombreuses situations, y compris les environnements contraints tels que la communication dans les contextes Machine to Machine (M2M) et Internet des objets (IoT) où une faible empreinte de code est requise et/ou la bande passante du réseau est primordiale."

Citation de la spécification officielle MQTT 3.1.1.

Donc, fondamentalement, nous pouvons publier un message quelque part d'un côté et de l'autre côté, nous pouvons écouter ces messages et faire quelque chose avec les données. MQTT prend en charge les "sujets", les sujets sont des chaînes que le courtier utilise pour filtrer les messages pour chaque client. Par conséquent, si nous publions un message dans le sujet "/radiation", un auditeur doit s'abonner au même sujet pour obtenir les messages que nous envoyons.

Voici un excellent tutoriel sur MQTT en détail:

L'utilisation du serveur Hive gratuit présente certains inconvénients tels que:

- toute personne écoutant votre sujet recevra vos messages

- s'il tombe en panne ou nécessite un paiement plus tard, vous ne pourrez pas l'utiliser (sauf si vous payez)

- si quelqu'un qui publie des messages sur le même sujet, vous recevrez également ses messages, il peut publier des messages incompatibles et casser vos graphiques HASS

Utiliser un serveur privé

Si vous ne souhaitez pas utiliser le serveur public gratuit, vous avez la possibilité d'utiliser un serveur privé. Nous allons installer le Mosquitto MQTT sur un serveur ubuntu/debian comme un raspberry pi ou un ordinateur.

Mosquitto est un serveur qui implémente le protocole MQTT et c'est gratuit.

Pour l'installer, connectez-vous à votre raspnerry pi ou à un autre serveur basé sur Debian et exécutez:

mise à jour sudo apt

sudo apt install -y mosquitto mosquitto-clients sudo systemctl enable mosquitto.service

Cela mettra à jour le référentiel, installera le serveur et le client mosquiito et lui permettra d'exécuter un service au démarrage

Pour que l'adresse IP du serveur s'exécute:

nom d'hôte -I

et il affichera quelque chose comme:

192.168.1.52 172.17.0.1 172.18.0.1

Donc mon IP est 192.168.1.52, dans les commandes ci-dessous, remplacez-le par votre propre IP

Vous pouvez tester le serveur MQTT en publiant un message et en le recevant avec l'outil console, pour cela deux terminaux doivent être ouverts, celui qui écoute un message, celui qui publiera le message.

D'abord dans un terminal, exécutez cette commande pour écouter un message sur "/some-topic"

mosquitto_sub -h 192.168.1.52 -t /un-sujet

Ouvrez un autre terminal et publiez un message sur ce sujet:

mosquitto_pub -h 192.168.1.52 -t /un-sujet -m '{"humidité": 74.0}'

Dans le premier terminal, vous devriez voir ' {"humidité": 74.0}' imprimé.

Attention particulière:

- cette configuration suppose que HASS, Mosquitto et NodeMCU sont connectés au même réseau WIFI et qu'il n'y a pas de règles de pare-feu et qu'ils peuvent communiquer librement

- le serveur Mosquitt MQTT n'a pas de nom d'utilisateur/mot de passe, si vous souhaitez configurer les informations d'identification, consultez ceci: https://www.steves-internet-guide.com/mqtt-username-password-example/ Vous devrez également configurer les informations d'identification dans Home Assistant et dans le croquis arduino

Étape 7: OTA (Over the Air Updates) pour le NodeMCU

Les mises à jour sans fil signifient que la carte de développement peut être flashée sans fil sans avoir besoin d'un câble physique.

Arduino IDE prend en charge cette fonctionnalité pour la série ESP8266 et certaines autres cartes:

- nécessite un flash initial via le câble USB

- crée un port virtuel via WIFI et il n'est visible que depuis Arduino IDE

- aucune information de débogage série n'est disponible

- prend en charge la protection par mot de passe

Pour activer l'OTA dans un sketch ESP8266, commencez par inclure la bibliothèque:

#include "ArduinoOTA.h"

Définissez également cette constante de mot de passe d'esquisse:

#define SKETCHPASS "un_mot_de_passe"

Dans la section de configuration, ajoutez ces lignes:

while (WiFi.waitForConnectResult() != WL_CONNECTED) {

Serial.println("Echec de la connexion ! Redémarrage…"); retard (5000); ESP.restart(); } ArduinoOTA.setPassword(SKETCHPASS); ArduinoOTA.onStart(() { Type de chaîne; if (ArduinoOTA.getCommand() == U_FLASH) { type = "sketch"; } else { // U_FS type = "filesystem"; } Serial.println("Démarrer la mise à jour " + taper); }); ArduinoOTA.onEnd(() { Serial.println("\nEnd"); }); ArduinoOTA.onProgress((progress int non signé, total int non signé) { Serial.printf("Progress: %u%%\r", (progress / (total / 100))); }); ArduinoOTA.onError((ota_error_t error) { Serial.printf("Error[%u]: ", error); if (error == OTA_AUTH_ERROR) { Serial.println("Auth Failed"); } else if (error == OTA_BEGIN_ERROR) { Serial.println("Begin Failed"); } else if (error == OTA_CONNECT_ERROR) { Serial.println("Connect Failed"); } else if (error == OTA_RECEIVE_ERROR) { Serial.println(" Receive Failed"); } else if (error == OTA_END_ERROR) { Serial.println("End Failed"); } }); ArduinoOTA.begin(); Serial.print("Adresse IP: "); Serial.println(WiFi.localIP());

Et dans la section loop, ajoutez cette ligne:

ArduinoOTA.handle();

Après le téléchargement de votre code initial après le démarrage de la carte, vous devriez voir dans l'IDE Arduino dans la section Outils-> Port deux types de ports:

Ports série: /dev/ttyUSB0 (par exemple)

Ports réseau: esp8266-xxxxx à 192.168.1.xxx

Maintenant, vous pouvez sélectionner le port réseau et télécharger la télécommande du croquis, vous serez invité à saisir le mot de passe du croquis (celui que vous avez défini dans une constante ci-dessus)

Étape 8: Conclusions, travaux futurs

Ce tutoriel peut être facilement modifié pour envoyer des données sur d'autres types de capteurs:

- si votre capteur est directement pris en charge par NodeMCU via une bibliothèque, regroupez simplement les données du capteur et transférez-les directement via MQTT

- si la bibliothèque de capteurs ne fonctionne pas avec NodeMCU mais que c'est uniquement pour Arduino, téléchargez votre code sur l'arduino, affichez la valeur via la ligne série et lisez-la dans le NodeMCU et appuyez dessus (comme nous l'avons fait avec le compteur Geiger)

Nous pouvons même le modifier pour envoyer des données de plusieurs capteurs comme ceci:

- connectez vos capteurs au NodeMCU

- interroger les données de chaque capteur

- pour chacun des capteurs publier les données sur un sujet différent

- dans le HASS définir plusieurs capteurs (comme nous l'avons fait avec le geiger) qui écouteront différents sujets