Niveau cuve d'eau via JSN-SR04T en MQTT pour openHAB 3

Je voulais partager avec vous cette expérience d'allier un composant électronique simple avec OpenHAB.
Dans cet exemple j'utiliserai la version openHAB 3 qui est beaucoup plus "user friendly" c'est à dire "agréable" et accessible que sa petite soeur openHAB v2.
De plus cela permettre de poser les bases d'une mise en oeuvre d'openHAB v3 sous MQTT.

Contexte :
Vous avez un récupérateur d'eau et vous ne savez jamais quel est le niveau d'eau restant dedans.
Ce processus peut simplement vous indiquer la hauteur d'eau (donc son volume) ou permettre de déclencher des règles précises de gestion que vous souhaitez d'après ce niveau.
En ce qui me concerne, j'ai un récupérateur de 3500 L et je ne sais jamais - à moins de l'ouvrir - quel est le niveau d'eau restant.

En fait ce que l'on veut précisement c'est savoir quel est le pourcentage d'eau qui occupe la cuve.

page


J'avais déjà mis en place ce process sur Home Assistant. Je me devais de le tester et valider sur openHAB 3 ;o)

 sr04

 

PARTIE 1 : Quels composants utiliser et pourquoi ?

N'étant pas d'un niveau en électronique qui me permet d'aller loin dans la mise en oeuvre je me suis mis à chercher un moyen simple et peu honereux.
Après avec recensé les techniques, 3 étaient possibles.

1. Un appareil dédié qui mesure et affiche en temps réel le volume de ma cuve.
Autant le dire de suite, j'ai vite été calmé par le prix (envrion 50 à 150 voir 350 euros) et par la possibilité de mise en oeuvre parfois (centrée, fixer..etc..).
D'autresont moins cher (surtout sur Banggood ou Aliexpress) et comportent même un afficheur, mais le cable est trop court ou alors le paramétrage ne convient pas... bref pas flexible et
surtout le lien avec la domotique n'est pas simple.

2. Certains mettent enplace une grande barre sur lequel on place tous les x centimetres des capteurs d'eau. Suivant les capteurs qui informent qu'ils sont au contact de l'eau, on peut savoir la hauteur d'eau.
Perso en 2021 je trouve que cela fait usine à gaz et qu'il y a plus simple...
https://www.framboise314.fr/une-mesure-de-niveau-deau-avec-un-raspberry-pi/

3. Dernière solution c'est l'utilisation de capteur type ultrasons qui va determiner une distance entre le capteur et une sarface/objet touché.
Ce composant électronique est peu honéreux et surtout il peut d'adapter à plein de systèmes très facillement (Ardunio, Raspberry... et surtout un WEMOS D1 WIFI qui coût quasi rien !)
C'est ce choix que j'ai fait et que je vais vous détailler.


Quelle difference entre HC-SR04 JSN-SR04T ?

Le plus connu est le HC-SR04 car dans les utilisations arduino il est fortement utilisé.
Cependant, même si les deux modèles remplissent le même rôle, l'utilisation du JSN-SR04T est obligatoire. Pourquoi ? Car ce dernier est waterproof et l'autre non...
Vital dans notre cas car dans une cuve de récupération en cas de puie, humidité, condensation etc... notre système ne tiendrait pas longtemps...
Par contre votre choix doit obligatoirement s'orienté vers le module JSN-SR04T-3.0 : la version 3.0 est OBLIGATOIRE car stable (les anciennes ont des pb, j'ai pu le vérifier moi-même su un de mes capteurs)

 sr041

sr042

Quels matériels nécessaires en plus du JSN-SR04T ?

Le matériel DE BASE est le suivant :
- 1 WEMOS D1 mini (environ 1,5 euros) : Le Wemos va permettre de communiquer les prises de mesures faites par le module JSN-SR04T et le transmettre en MQTT

wemosD1mini
- 1 cable USB <-> micro USB pour alimenter, communiquer et flasher le WEMOS
- Un simple chargeur USB pour rendre le composant SR04T indépendant sur une prise électrique
- Des connecteurs - à fixer/souder sur le Wemos - qui serviront à connecter les fils de connexions entre le Wemos et le composant JSN-SR04T
Préparer le Wemos avec les connecteurs soudés et prêts pour le flashage.

connecteurs

C'est le minimum pour obtenir une mesure de distance entre le capteur et la surface de l'eau.
Ensuite on pourra rajouter d'autres choses suivant votre besoin (rallonge tpe rj45 pour le module SR04...etc...)

- A présent il vous faut connecter les fils de connexion aux connecteurs du WEMOS en respectant le tableau suivant :

JST-SR04T WEMOS D1 Mini
 5V 5V
 GND GND
 TRIG (RX) D7 (GPIO13)
ECHO (TX) D6 (GPIO12)

On est prêt à flasher !

Tips : Si vous avez une imprimante 3D je vous recommande d'imprimer ces petits boitiers très pratiques :
pour le Wemos
https://www.thingiverse.com/thing:1768820
pour le module SR04T
https://www.thingiverse.com/thing:3346226


PARTIE 2 : Flasher le Wemos D1 mini via Tasmota

 

Tout petit et rapide rappel : qu'est ce que Tasmota ?
C'est un firmware qui permet de gérer - par une couche software - des composants de type ESP8266. En sortie cela nous permet d'exploiter un mode WIFI + MQTT... etc... bref c'est génial et c'est gratuit...
Pour plus d'infos c'est ici :
https://tasmota.github.io/docs/

Il y a une séquence d'actions pour flasher le Wemos. Cela se fait très facilement.

1. Brancher votre Wemos au micro usb qui est lui même relié à un port usb de votre ordi.
Dans la photo d'illustration ci-dessous le module SR04 n'est pas connecté au Wemos mais chez vous bien entendu tout est relié...

wemos ordi

2. Télécharger ce petit utilitaire qui va vous permettre de transférer le firware Tasmota sur votre Wemos D1 mini.
Il s'appelle Tasmotizer (version actuelle : Tasmotizer 1.2)
Vous pouvez le télécharger ici : (prenez la version x64 ou 32 bits selon votre système)
https://github.com/tasmota/tasmotizer/releases

Cet outil est génial car il va vous faciler grandement la vie : en 3 manipulations très simple, votre Wemos est flashé !

3.Lancez cet utilitaire sur votre ordi en ayant une connexion internet car il va récupérer la dernière version de Tasmota (vous pouvez aussi bien sûr déposer manuellement votre propre version Tasmota en fichier xxxx.bin si vous le souhaitez)

 Tasmotizer récupère le port de connexion de votre USB branché sur votre Wemos et il vous demande quelle version implémenter, pensez à cocher de supprimer ce qu'il y avait auparavant  (vous pouvez aussi sauvegarder votre ancienne version sur le Wemos etc...)
LE PLUS IMPORTANT A RETENIR EST QU'IL FAUT PRENDRE LA VERSION tasmota-sensors.bin car la version standard ne comporte pas la gestion du SR04. (Pour info en version 8.1.0 standard on peut le faire mais ensuite il faut utiliser ce fichier là et pas un autre)

tasmotizer 

Vous pouvez cliquer sur le bouton Tasmotize.

tasmotizer2

Le flashage se fait tout seul...

tasmotizer3
A la fin du processus, débranchez votre cable USB sur l'ordinateur, rebranchez et patientez 10s avant de cliquer sur le bouton "OK"
A présent on va mettre à jour directement la configuration WIFI dans Tasmota (pratique ! on est quitte de se connecter sur le réseau Tasmota dédié et paramétrer manuellement)

Pour cela, cliquer sur le bouton "Send config" et configurer votre réseau WIFI + Password.. Vous pouvez aussi compléter le recovery WIFI au cas où vous perdez votre WIFI courant.
La partie MQTT sera configurée directement dans Tasmota (plus bas)

tasmotizer4

On clique sur "Save".
A présent on va récupérer l'adresse IP où démarre notre Wemos. Pour cela on clique sur "Get IP".

tasmotizer5
A présent vous pouvez saisir cette IP dans votre navigateur ; cela affiche la configuration de base de Tasmota.

tasmota

 

PARTIE 3 : Configurer Tasmota

 

A présent nous allons configurer notre module SR04 dans Tasmota.
On va dans "configuration" puis "module parameters".
On choisi le module de type GENERIC 18 et "save". Le module "reboot" donc patientez et vous arriverez au menu de Tasmota.

tasmota2

tasmota3

A présent on défini les connecteurs D6 et D7 pour communiquer (RT et TX, rappelez vous du tableau de connexion dans le chapitre 1).
On sauvegarde. Cela reboot encore et on arrive à nouveau au menu et là... ô miracle, l'affichage de la distance mesuré par la sonde s'affiche !!

tasmota4

 
On va à présent donner un titre plus précis que "Tasmota", on va l'appeler "JSN-SR04T" et on laisse l'émulation à "None".

tasmota6
tasmota7

 Maintenant que l'on a la mesure de la distance, et que l'on a nommé notre Tasmota, il nous faut préparer le mode de communication de ces infos avec openHAB.
Le protocol utilisé est MQTT. Nous allons donc configurer la partie MQTT du Wemos pour pouvoir ensuite dialoguer avec openHAB.

Pour cela il nous faut décrire le Host c'est à dire l'IP de notre Broker MQTT (que l'on va installer sur notre openHAB ou que l'on a installé indépendement), le port (c'est toujours 1883), le user/password de votre MQTT Broker et enfin le Topic.
Ce dernier point est à ne pas négliger car c'est ce qui servira à la subscribtion sous MQTT et qui permet d'identiifer votre module dans MQTT dans mon cas je n'en ai qu'un donc je l'ai appelé JSN-SR04T.

 On sauvegarde et cela va relancer le module pour la prise en compte

 tasmota9

 Il nous reste une toute dernière modification à faire.
Par défaut la prise de mesure se fait tous les 300s cad toutes les 5min. On va réduire à 30s c'est plus pratique.
Pour cela on va dans le menu de "Logging parameters" et on change le champ "Telemetry period" de 300 par défaut à 30

tasmota8
On sauvegarde.


On a fini à présent avec le le composant.
A présent on va s'occuper de MQTT.


PARTIE 4 : Installer et configurer MQTT

 MQTT peut s'installer de 4 façons :

- Votre openhab est sous openhabian, c'est le cas le plus simple et le plus rapide.
Il faut vous connecter avec putty à votre console et aller dans le menu de configuration qui est très pratique via la commande :

sudo openhabian-config

Allez dans le menu 20 : "Optional Components"
Puis 23 | Mosquitto MQTT broker Eclipse Mosquitto

 Il va vous proposer l'installation de Mosquitto qui est un broker MQTT gratuit et très répendu. Vous allez préciser un user / password...etc..
Rien de compliqué. Après une relance c'est fait, votre MQTT est opérationnel sur le port 1883.

- Vous avez une installation linux indépendante d'openhabian, je vous conseille donc d'installer Mosquitto via des installations linux classiques.
Je vous invite à suivre ce tutoriel ici qui est très bien fait :
https://www.tutos.eu/4910

- Vous êtes sous Docker et vous voulez ajouter un container MQTT Mosquitto.
J'ai fait un tutoriel ici :
https://macleod.hfstudio.com/index.php/fr/tut/160-installer-le-message-broker-mosquitto-dans-un-container-docker

- Vous avez déjà un brocker situé sur un autre serveur (windows ou autre...). Simplement récupérez le user/password + IP + port qui seront utiles pour la suite.

 

Je ne peux pas m'empécher de vous donner 2 astuces très utiles :

1. Tasmota propose une log détaillées de l'activité du module.
Pour cela allez sur l'IP de votre module dans le menu "Console"

tasmota11

Ici on voit clairement que les posts MQTT passent bien et via 2 topics :
MQT: tele/JSN-SR04T/STATE : donne le status du composant.
MQT: tele/JSN-SR04T/SENSOR : donne le résultat (la distance)


2. Utilisation d'un client MQTT pour suivre l'activité et tracer les messages postés.
Quand votre module va poster ses informations il est très pratique de vérifier qu'elles sont bien poussées dans MQTT et que c'est opérationnel.
Je recommande l'utilisation du logiciel gratuit : MQTT.fx disponible ici :
https://mqttfx.jensd.de/

 

MQTTfx

On peut souscrire pour trapper les infos postées.
Dans notre cas les données sont postées dans tele/JSN-SR04T/SENSOR (souvenez vous notre configuration MQTT dans Tasmota)

MQTTfx2

Cela confirme ce que l'on voit dans les logs Tasmota du point précédent !

 

PARTIE 5 : La configuration sous openHAB 3

 

 Bien évidement - et ce depuis longtemps - openHAB sait gérer MQTT.

1. Binding MQTT
Lorsque vous êtes dans l'administration d'openhab (url https://votreipopenhab:8080, il vous faut en premier installer le binding.
Le binding correspond à un composant qui va savoir gérer un matériel (par un protocol de communication, une définition de canaux etc...)
Dans notre cas il nous faut installer le binding MQTT.

Aller dans "Paramètres" au niveau des "Add-ons" et cloquer sur "Bindings" .
A présent cliquer sur la petite croix bleue en bas à droite de la page et recherchez "MQTT".
Il vous trouvera la version courante du binding et vous propose de l'installer. C'est rapide (10s).
En retournant dans votre menu "Bindings" vous verrez qu'il est installé.


openhab

2. Définir les objets (Things)
Le binding étant réalisé nous pouvons à présent référencer notre objet (c'est à dire le SR04T).
Cet objet sera de type MQTT car le mode de communication entre le SR04T et openHAB se fait en MQTT.
MAIS avant ça il nous faut définir le Broker MQTT qui n'a pas encore été créé (le Broker n'est à créer qu'une fois pour votre gestion de tous vos composants en MQTT bien entendu)

 

Le Thing de type Broker MQTT
Nous allons donc dans le menu d'openHAB dans "Paramètres" puis "Things". L'objet en peut être détecté automatiquement. Nous allons donc l'ajouter manuellement.
On clique sur la croix bleue en bas à droite pour ajouter.
Nous voulons ajouter un élement dépendant du binding MQTT. (on choisit donc MQTT binding)
Et on choisi le type MQTT Broker.

openhab2
Nous avons donc à compléter la configuration de notre broker Mosquitto.
On donne un nom ("MQTT Broker"), on click sur l'option "advanced" pour optenir plus d'options.
On précise l'IP de notre Broker le port (1883 par défaut)

openhab3

il faut aussi définir notre user/password défini dans la config Mosquitto

openhab4


On sauvegarde. A l'issu, openHAB vous confirme si il a accès au Broker MQTT ou pas via le status.

openhab5


Le Thing de type Generic MQTT

Maintenant que l'objet Broker est défini, il nous reste à ajouter l'objet SR04T.
C'est un objet de type Generic MQTT c'est à dire que c'est un objet MQTT standard.

 On recommence :
Nous allons donc dans le menu d'openHAB dans "Paramètres" puis "Things". L'objet en peut être détecté automatiquement. Nous allons donc l'ajouter manuellement.
On clique sur la croix bleue en bas à droite pour ajouter.
Nous voulons ajouter un élement dépendant du binding MQTT. (on choisit donc MQTT binding)
Et on choisi le type Generic MQTT Thing.

Dans l'onglet au dessu "Thing"
Je lui donne le nom JSN-SR04T et il fait partie de mon emplacement gExterieur.
Je lui assigne le nom de mon Broker qui est : MQTT Broker (créé précédement)

openhab6
Ensuite on va dans l'onglet "Channel" pour lui définir les caractéristiques de notre objet ( 'les canaux' qu'on va utiliser)
On clique sur "Add Channel" et le type sera "Pourcentage Value"

openhab7

Petite précisions.
Vous avez remarqué que le type de canal est "pourcentage" alors que le SR04T gère... une distance...
Comment allons nous obtenir ce calcul de pourcentage alors que MQTT ne nous transmet qu'un nombre qui correspond à la distance...
Nous allons utiliser.. la Transformation sous openHAB. On verra ça plus loin.
En attendant il nous faut configurer le Channel.
On précise le topic, et l'unité de mesure "%" pour l'affichage.

openhab8
On sauvegarde.
Le canal pour l'information de notre module est créé.



L'item du Canal de notre objet (Thing)


A présent on va lui associer un item qui nous servira pour les affichages. Cela s'appelle "Link Channel to item".
On clique sur "Add link to item" au niveau du channel.

On créé un nouvel item. On lui associe des informations comme le type (nombre dnas notre cas), un label qu'on retrouvera dans la liste des items, et des descriptions.

openhab9

Un point très important est en bas : on lui associe un JS (javascript) que j'ai appelé ici "pourcentage.js" : ceci concerne en fait ce que j'ai expliqué plus haut ; la transformation.
On sauvegarde notre item pour qu'il soit créé.
C'est à dire qu'on va convertir le nombre lu (qui est une distance) et on va calculer ce que cela signifie en terme d'occupation de la cuve (en pourcentage) par une petite formule mathématique simple qui es définie dans le JS.

Ce fichier javascript est situé sur votre serveur où est installé openHAB dans le répertoire  /etc/openhab/transform

openhab10


On créé le fichier nommé pourcentage.js qui comporte ceci :

(function(i) {
// i = 30 => cuve pleine => 100 %
// i = 150 => cuve vide => 0 %
var i_cuve_vide = 150; // hauteur i mesuree en cm quand cuve vide
var i_cuve_pleine = 30; // hauteur i mesuree en cm quand cuve pleine

var pourcent = (i_cuve_vide - i) / ((i_cuve_vide - i_cuve_pleine) / 100);
var pourcent = pourcent.toFixed(2);
return pourcent;
})(input)

 

Evidemment vous adaptez les variables i_cuve_vide et i_cuve_pleine avec les mesures de hauteurs de votre module SR04T avec vos 2 hauteurs mesurées cuve vide et cuve pleine en cm.
La fonction toFixed permet de ne positionner que 2 chiffres après la virgule.

Donc pour ceux qui ne veulent que la hauteur en cm du SR04T, il ne faut pas implémenter ceci mais je trouve pratique d'avoir un visuel de pourcentage qu'une hauteur en cm pour une mesure de volume...

On vérifie ce que l'on a fait dans la vue des items !
On va dans "Administration" "Paramètres" "Items".

openhab11

Il applique bien la formule du JS et affiche en % !


La configration de l'affichage

On peut à présenter montrer quelque chose de joli pour afficher notre pourcentage d'occupation de cuve !
On va dans "Administration" "Paramètres" "Pages" et on clique sur la page d'overview. (aperçu) et on ajoute un element (cliquer sur la croix dans le gros rectangle)

On choisi un type d'affiche "Gauge" qu'on va paramétrer en cliquant sur le bouton noir (écran) créé.


openhab12

 Cliquer sur "Configure Widget"
Bon je vous laisse personnaliser à votre goût l'affichage... notez qu'il faut assigner l'item que vous voulez afficher et comment se présente votre gauge..

openhab13

Voilà !!!
C'est opérationnel à présent !
J'espère que ce tutoriel que j'ai voulu le plus complet possible vous a plu.
N'hésitez pas à me faire des retours !
++

NOTA : pour information si vous devez faire une rallonge, c'est avec un RJ45 entre le WemosD1 et carte JSN (sur plusieurs dizaines de mètres) !

{jcomments on}

 

Installer le message broker Mosquitto dans un container Docker pour openHAB3

Quel est l'interêt de faire ça ?
Cela concerne bien entenu ceux qui ont installé openHAB 3 via un cotainer Docker.
C'est juste une synthèse de la manière à opérer et à ensuite référencer cela sous openHAB et peut-être que cela dépannera certains... car il y a certains pièges...


1. Récupération de l'image sous Docker HUB :

https://hub.docker.com/_/eclipse-mosquitto

Faire un pull :
docker pull eclipse-mosquitto


2. Démarrer le container :
docker run -it --name mosquitto -p 1883:1883 eclipse-mosquitto 

 

Personnelement je préfère utiliser le Docker-compose (via Portainer c'est trop pratique !)
Voici donc mon docker compose :

version: '2.4'

services:
app:
container_name: mosquitto
image: eclipse-mosquitto:latest
restart: unless-stopped
ports:
- 1883:1883
- 9001:9001
volumes:
- /etc/localtime:/etc/localtime:ro
- /etc/timezone:/etc/timezone:ro
- /mosquitto/data:/mosquitto/data
- /mosquitto/log:/mosquitto/log

(pour info, le port 1883 est crucial, le 9001 est optionnel car c'est pour une utilisation de MQTT via des WebSockets)
Bon jusque là rien de particulier et de bien difficile.
Mais il manque quelque chose de crucial !

3. La mise à jour du fichier de conf


Faites :

sudo docker exec -it mosquitto /bin/sh


Et à présent éditez le fichier de conf :

/ # vi /mosquitto/config/mosquitto.conf


A la fin ajoutez ceci :

allow_anonymous true
listener 1883
persistence true
persistence_location /mosquitto/data/
log_dest file /mosquitto/log/mosquitto.log

 

A présent on quitte cet env. on revient sur notre terminal pour faire un Arrêt/Relance de notre container.

docker stop mosquitto

docker start mosquitto

 

Notre Broker Mosquitto est prêt !
On va à présent le configurer dans openHAB.

4. La configuration dans openHAB

 

a- En premier il faut installer le binding MQTT dans openHAB 3
Aller dans "Paramètres" puis "Add-ons" à droite. Puis cliquer sur "Bindings".
Cliquez dans le "+" en bas à droite de l'écran pour ajouter un Binding.
Dans la liste chercher "MQTT Binding" et l'installer.

b- Le Binding étant installé il faut à présent crééer l'objet Things de type MQTT Broker.
Donc on va dans Thnigs et on clique en bas à droite sur "+" pour ajouter un objet de type MQTT Binding.

Il apparait une liste d'ajout manuels et sélectionner "MQTT Broker" de type Bridge.

Souvenez vous que le port de communication de MQTT que nous avons définis dans docker est le 1883.
Il est utilisé par défaut donc inutile de le définir dans openHAB, il vous faut juste définir votre IP de serveur et c'est tout.

Votre Broker MQTT est pêt ! Pour en être sûr le voyant vert de status ONLIVE s'affiche pour votre Things MQTT Broker.

mqtt


Exécuter des commandes system via openHAB

Lors de mes tests de configurations il m'est arrivé plusieurs fois d'avoir un besoin d'exécution de traitements (scripts) ou simplement de passer des commandes system sur mon Raspberry pour relancer openHAB, voir rebooter.
Ce petit tutoriel vous explique comment procéder.

 

Exécuter des commandes system via openHAB

 

Documentation
Il existe un binding qui gère cela évidement :o)
La documentation est là : https://www.openhab.org/addons/bindings/exec/
Un exemple d'application des RULES au binding peut être trouvé ici : https://guiott.com/?page_id=2664

1. Installer le binding "Exec binding"

Comme d'habitude, le binding se trouve dans "Add-ons" de votre menu PaperUI puis "Bindings". Cliquer sur INSTALL sur votre droite.
Mon exemple montre la version binding-exec-2.5.2

tutoriel exec

2. Création des fichiers de configuration

Via PUTTY donc en mode console, connectez-vous sur votre Raspberry.
Il vous faut à présent faut créer le répertoire 'misc' s'il n'existe pas :

On va dans le répertoire des fichiers de configurations (correspond au répertoire $OPENHAB_CONF) :

cd /etc/openhab2
mkdir misc

 

 Puis on édite le fichier exec.whitelist :

sudo vi exec.whitelist

 

Dans ce fichier nous allons mettre les commandes COMPLETES qui sont autorisées.
Exemple :

/usr/bin/sudo /sbin/reboot
/usr/bin/sudo /bin/systemctl restart openhab2.service




 

Ensuite il ne faut pas oublier de donner les bons droits aux fichiers/repertoires que l'on vient de créer sinon openHAB ne saura pas y accéder :

chown -R openhab:openhab /etc/openhab2/misc



3. Définition des objets "Things" dans openHAB


Il nous faut définir à présent la configuration du fichier Things qui doit se trouver dans /etc/openhab2/things que l'on peut appeler par exemple : exec.things (Vous pouvez aussi créer votre objet via PaperUI aussi !)
Voici un exemple de contenu :

Thing exec:command:Reboot "Reboot" [command="/usr/bin/sudo /sbin/reboot", interval=0, autorun=false]
Thing exec:command:RestartOpenHAB "RESTART openHAB" [command="/usr/bin/sudo /bin/systemctl restart openhab2.service", interval=0, autorun=false]



4. Définition des objets "Items" dans openHAB

Ce fichier doit se situer dans /etc/openhab2/items que l'on peut nommer par exemple : exec.items (Vous pouvez aussi créer votre objet via PaperUI aussi !)
Voici un exemple de contenu :

Switch Do_Reboot "Reboot" (gCommandesSystem) { channel="exec:command:Reboot:run" }
Switch Do_RestartopenHAB "Restart openHAB" (gCommandesSystem) { channel="exec:command:RestartOpenHAB:run" }

 

5. Autorisations sudo au user openhab

Il faut à présent donner l'autorisation au user openhab d'executer les commandes passées par un sudo.
Pour cela il faut editer le fichier sudoers via OBLIGATOIREMENT la commande :

sudo visudo

 
et y ajouter la ligne :

openhab ALL=NOPASSWD: ALL





6. Mettre à jour le fichier de sitemap

Le fichier de type sitemap permet l'action à distance via votre smartphone par exemple.

ATTENTION !!!!!!! Le type d'action est un switch. Dans la console paperUI via le menu "Control" LE BOUTON EST GRISE ET C'EST NORMAL (l'action ne peut se faire via cette méthode)

Donc accédez à votre/vos boutons d'actions par sitemap !
Dans mon exemple, j'ai un groupe défini dans un fichier item lié aux commandes qui s'appelle gCommandesSystem (que j'avais défini ainsi dans un groups.items : Group gCommandesSystem "Commandes système Raspberry" <shield>)
Donc dans le fichier sitemap que j'ai appelé maison.sitemap situé dans le répertoire /etc/openhab2/sitemaps je fais appel au groupe :

Frame label="System"
{
 Group item=gCommandesSystem
}

 
Voici un petit aperçu :

tutoriel exec2

 

puis

tutoriel exec3

 

 

7. FINI

Voilà !
Evidement d'autres choses uper sympa peuvent être faites, notement des appels à des scripts shell ou perl qui pourront faire des actions techniques et automatisées par un simple déclenchement de switch sur votre application smartphone openHAB !
Génial non ?

Have fun !

Sonoff RF Bridge WIFI 433 - Flashage et configuration sous openHAB

J'ai beaucoup hésité à faire cet article qui m'a pris du temps.
En effet évoquer le flashage et l'utilsiation du composant Sonoff RF Bridge semble un peu superflux du fait que beaucoup de personnes l'ont déjà détaillé dans de nombreux articles.
Pourtant... pourtant je me dois je lui consacrer un tutoriel car même si la partie matériel sera la même que pour du flashage Tasmota classique, la configuration sous openHAB peut
rapidement prendre beaucoup de temps.
Comme d'habitude, je n'hésiterai pas à vous donner des liens d'articles bien faits qui pourront vous aider en parallèle.

 

Sonoff RF Bridge WIFI 433 - Flashage et configuration sous openHAB

 

Avant d'attaquer directement sur le comment du flashage du produit, il me faut d'abord expliquer quel est l'interêt du composant et pourquoi tout le monde s'intéresse à lui.



20191021 174928

Ce produit est peu cher (aux alentours de 6/7 euros sur internet sur des sites tels Aliexpress ou Banggood), son alimentaion peu se faire via un simple cable micro usb type b sur un raspberry ou un port d'ordinateur
ou via une prise électrique avec un chageur type téléphone. (le cable et le chargeur ne sont jamais compris dans l'offre produit)
Il est de petite dimension (carré de 6.2 cm pour une hauteur de 2cm) et possède 2 voyants un rouge et un bleu. Le rouge signifie la réception d'un signal et le bleu l'initialisation.

Son but ? Capter toutes les fréquences 433 Mhz standards. C'est à dire qu'il ne gère pas de multi-protocoles qui utilisent cette fréquences à leur propre format mais des appareils qui émettront des signaux simples en 433 Mhz.
Etant donné que j'ai déjà fait des articles sur le RFXcom vous allez me demander quelle est la différence...
LE RFXcom permet l'interprétation de beaucoup plus de type de sognaux en 433 Mhz et il permet en plus de gérer des formats spéciaux comme le RTS (de chez Somfy... ou autres)
Soyons clairs, le Sonoff RF Bridge ne le fait pas !
Par contre le très très gros avantage et que c'est un matériel qui peut être flashé pour utiliser la protocol MQTT via WIFI.
Là c'est super intéressant car pour 7 euros vous pouvez capter les signaux d'une très grande partie de produits standards et bon marché pour les interpréter via MQTT dans openHAB et en faire des règles ou autre...
C'est pour cette raison que le produit est si populaire !
Sonoff + Flashing du firewareTasmota = MQTT en WIFI pour les fréquences 433 standards !

Prerequis matériels

 

Le Flashing

Il suffit de peu de matériel pour flasher un tel produit et si vous avez peur dites vous que pour 7 euros l'investissements permet de prendre le risque (d'ailleurs il n'y a quasi aucun risque !)
Avant tout on ne branche rien au Sonoff RF Bridge !

a. Opération d'ouverture

20191021 175039

on retourne le module, on ôte les 4 petits caoutchouc de protection noirs aux 4 coins (ils sont simplement collés). On les met bien de côté pour pas les perdre...

20191021 175148

On dévisse et pareil, on perd pas les 4 vis...

20191021 175319

A présent on sort la carte de circuit imprimé délicatement. Elle vient facilement.

20191021 175457

Le papier blanc sert à réfléchir la led verte centrale qui affiche la marque Sonoff quand c'est connecté à une alimentation.
On va rabattre le connecteur du papier blanc vers la gauche d'après la photo ci-dessus pour accéder aux composants qui sont en dessous.

20191021 175539

Parfait. A présent voyez en rouge les 4 trous qui nous intéressent. C'est là où il nous faut relier notre Sonof RF Bridge avec un adaptateur type FTDI qui va nous permettre de dialoguer
avec le Sonoff... et donc de lui pousser un autre firmeware... qui sera le Tasmota.
Notez aussi le rectangle vert situé à coté du rectangle rouge. C'est un commutateur qu'il faut à présent positionner en direction du rectangle rouge ainsi afin que le Sonoff se mette en mode apprentissage.

b. 4 petites soudures

20191021 183136

Perso, comme vous pouvez le voir sur la photo ci-dessus j'ai positionné 4 connecteurs (voyez sur la droite un ensemble que j'avais et pour laquel j'en ai pris 4 accolés)
puis leur au coupé un peu leur pate afin de n'avoir que peu de dépassement qui me permettra de souder facilement et de ne pas être géné par ces pattes
lorsque l'on reféremera le Sonoff à la fin.

 

20191021 183209

Voilà, c'est soudé. J'ai même réduit aussi un peu le dessus en les coupant un peu pour pouvoir bien rabattre le papier blanc et sa patte qui le maintient.

c. Raccorder

20191115 205246
A présent il faut relier à votre adaptateur FTDI.

Voici le tableau à respecter :

  BRIDGE RF 

  FTDI  

  Couleur de mon cable 

3.3V

VCC

Jaune

RX

TX

Vert

TX

RX

Bleu

GND

GND

Orange

Je vous donne en exemple mon adaptateur FTDI mais le votre a peut-être des positions de sorties différentes.
Une chose très importante à noter est le voltage. Si comme le mien ci-dessous par défaut le commutateur est positionné sur 5V surtout changez-le car il faut absoluement être en 3.3V !!

FTDI

d. Déterminer le port COM

  1. Brancher le câble USB sur l'ordinateur (alimentation reliée au FTDI) et pas celui du bridge !!! Et en même temps, maintenir le bouton d'appairage pendant 2s (petit bouton noir situé sur le côté du Sonoff Bridge)
  2. Vous allez entendre que Windows détecte un nouveau matériel. Il va installer le driver automatiquement.
  3. Il faut à présent rechercher le bon port COM utilisé par Windows.

Pour cela aller dans le "Gestionnaire de périphériques" et découvrez le port assigné.

Dans mon cas c'est le COM6 :

configuration

Retenez bien cette indication elle servira plus tard.

e. Prérequis logiciels

  1. Télécharger Python (dans mon cas version 3.8 64bits pour windows)

https://www.python.org/downloads/release/python-380/
Puis installez-le.
Ne pas oublier de positionner le répertoire Python dans le Path de Windows au moment de l'installation.

  1. Télécharger ESPTool (dans mon cas Version 2.8)

https://github.com/espressif/esptool/releases

Dézipper.
Aller dans le répertoire créé
(Dans mon cas c'est : D:\Tmp\Tasmota\esptool-2.8)

  1. Télécharger la dernière version du firmware Tasmota (dans mon cas c'est la version Sonoff-Tasmota v8.1.0

https://github.com/arendst/Tasmota/releases
Personnellement je suis français et je parle la langue de Molière donc je choisis le fichier binaire : Sonoff-FR.bin

;o)

Petite remarque : Ne prenez pas une trop vieille version de Tasmota car c'est seuelement depuis la version d'avril 2019 que la communication RF 433 - par exemple - est bien gérée dans Tasmota pour le Bridge Sonoff)
Tout ça pour dire que ce firmware est très bien maintenu et qu'il apporte toujours son lot de correctifs, nouveautés et compatibilités produits !
Les logiciels sont prêts.

 
f. Le flashing

Ouvrir une invite de commande en tant qu'administrateur (clic droit sur "invite de commande" exécuter en tant qu'administrateur)

 

 

Microsoft Windows [version 6.1.7601]
Copyright (c) 2009 Microsoft Corporation. Tous droits réservés.

C:\Windows\system32>d:
D:\>cd Tmp
D:\Tmp>cd Tasmota
D:\Tmp\Tasmota>cd esptool-2.8

A présent nous installons ESPTOOL pour PYTHON.

D:\Tmp\Tasmota\esptool-2.8>python setup.py install
running install running bdist_egg
running egg_info creating esptool.egg-info
writing esptool.egg-info\PKG-INFO
writing dependency_links to esptool.egg-info\dependency_links.txt
writing entry points to esptool.egg-info\entry_points.txt
writing requirements to esptool.egg-info\requires.txt
writing top-level names to esptool.egg-info\top_level.txt
writing manifest file 'esptool.egg-info\SOURCES.txt'
reading manifest file 'esptool.egg-info\SOURCES.txt'
reading manifest template 'MANIFEST.in'
no previously-included directories found matching 'ecdsa'
no previously-included directories found matching 'pyaes'
no previously-included directories found matching 'flasher_stub'
no previously-included directories found matching '.github'
warning: no previously-included files found matching '.git*'
warning: no previously-included files found matching '.travis*'
writing manifest file 'esptool.egg-info\SOURCES.txt'
installing library code to build\bdist.win-amd64\egg
running install_lib
running build_py creating build creating build\lib
copying esptool.py -> build\lib
copying espsecure.py -> build\lib
copying espefuse.py -> build\lib creating build\bdist.win-amd64
creating build\bdist.win-amd64\egg copying build\lib\espefuse.py -> build\bdist.win-amd64\egg
copying build\lib\espsecure.py -> build\bdist.win-amd64\egg
copying build\lib\esptool.py -> build\bdist.win-amd64\egg
byte-compiling build\bdist.win-amd64\egg\espefuse.py to espefuse.cpython-38.pyc
byte-compiling build\bdist.win-amd64\egg\espsecure.py to espsecure.cpython-38.pyc
byte-compiling build\bdist.win-amd64\egg\esptool.py to esptool.cpython-38.pyc
creating build\bdist.win-amd64\egg\EGG-INFO
copying esptool.egg-info\PKG-INFO -> build\bdist.win-amd64\egg\EGG-INFO
copying esptool.egg-info\SOURCES.txt -> build\bdist.win-amd64\egg\EGG-INFO
copying esptool.egg-info\dependency_links.txt -> build\bdist.win-amd64\egg\EGG-I NFO
copying esptool.egg-info\entry_points.txt -> build\bdist.win-amd64\egg\EGG-INFO
copying esptool.egg-info\requires.txt -> build\bdist.win-amd64\egg\EGG-INFO
copying esptool.egg-info\top_level.txt -> build\bdist.win-amd64\egg\EGG-INFO
zip_safe flag not set; analyzing archive contents...
__pycache__.esptool.cpython-38: module MAY be using inspect.trace
creating dist creating 'dist\esptool-2.8-py3.8.egg' and adding 'build\bdist.win-amd64\egg' to it
removing 'build\bdist.win-amd64\egg' (and everything under it)
Processing esptool-2.8-py3.8.egg
creating c:\program files\python38\lib\site-packages\esptool-2.8-py3.8.egg
Extracting esptool-2.8-py3.8.egg to c:\program files\python38\lib\site-packages
Adding esptool 2.8 to easy-install.pth file
Installing espefuse.py-script.py script to C:\Program Files\Python38\Scripts
Installing espefuse.py.exe script to C:\Program Files\Python38\Scripts
Installing espsecure.py-script.py script to C:\Program Files\Python38\Scripts
Installing espsecure.py.exe script to C:\Program Files\Python38\Scripts
Installing esptool.py-script.py script to C:\Program Files\Python38\Scripts
Installing esptool.py.exe script to C:\Program Files\Python38\Scripts
Installed c:\program files\python38\lib\site-packages\esptool-2.8-py3.8.egg
Processing dependencies for esptool==2.8
Searching for ecdsa Reading https://pypi.org/simple/ecdsa/
Downloading https://files.pythonhosted.org/packages/a2/25/3bb32da623b39a27a07d19 4cd58e4540224421d924661de2e694304ae4fa/ecdsa-0.14.1-py2.py3-none-any.whl#sha256= e108a5fe92c67639abae3260e43561af914e7fd0d27bae6d2ec1312ae7934dfe
Best match: ecdsa 0.14.1
Processing ecdsa-0.14.1-py2.py3-none-any.whl
Installing ecdsa-0.14.1-py2.py3-none-any.whl to c:\program files\python38\lib\si te-packages
writing requirements to c:\program files\python38\lib\site-packages\ecdsa-0.14.1 -py3.8.egg\EGG-INFO\requires.txt
Adding ecdsa 0.14.1 to easy-install.pth file
Installed c:\program files\python38\lib\site-packages\ecdsa-0.14.1-py3.8.egg
Searching for pyaes
Reading https://pypi.org/simple/pyaes/
Downloading https://files.pythonhosted.org/packages/44/66/2c17bae31c906613795711 fc78045c285048168919ace2220daa372c7d72/pyaes-1.6.1.tar.gz#sha256=02c1b1405c38d3c 370b085fb952dd8bea3fadcee6411ad99f312cc129c536d8f Best match: pyaes 1.6.1
Processing pyaes-1.6.1.tar.gz
Writing C:\Users\Admin\AppData\Local\Temp\easy_install-qw347uu_\pyaes-1.6.1\setu p.cfg
Running pyaes-1.6.1\setup.py -q bdist_egg --dist-dir C:\Users\Admin\AppData\Loca l\Temp\easy_install-qw347uu_\pyaes-1.6.1\egg-dist-tmp-to9bqvro zip_safe flag not set; analyzing archive contents...
Copying pyaes-1.6.1-py3.8.egg to c:\program files\python38\lib\site-packages Adding pyaes 1.6.1 to easy-install.pth file
Installed c:\program files\python38\lib\site-packages\pyaes-1.6.1-py3.8.egg Searching for pyserial>=3.0
Reading https://pypi.org/simple/pyserial/
Downloading https://files.pythonhosted.org/packages/0d/e4/2a744dd9e3be04a0c09074 14e2a01a7c88bb3915cbe3c8cc06e209f59c30/pyserial-3.4-py2.py3-none-any.whl#sha256= e0770fadba80c31013896c7e6ef703f72e7834965954a78e71a3049488d4d7d8
Best match: pyserial 3.4 Processing pyserial-3.4-py2.py3-none-any.whl
Installing pyserial-3.4-py2.py3-none-any.whl to c:\program files\python38\lib\si te-packages
Adding pyserial 3.4 to easy-install.pth file Installing miniterm.py script to C:\Program Files\Python38\Scripts
Installed c:\program files\python38\lib\site-packages\pyserial-3.4-py3.8.egg
Searching for six Reading https://pypi.org/simple/six/
Downloading https://files.pythonhosted.org/packages/65/26/32b8464df2a97e6dd1b656 ed26b2c194606c16fe163c695a992b36c11cdf/six-1.13.0-py2.py3-none-any.whl#sha256=1f 1b7d42e254082a9db6279deae68afb421ceba6158efa6131de7b3003ee93fd Best match: six 1.13.0
Processing six-1.13.0-py2.py3-none-any.whl
Installing six-1.13.0-py2.py3-none-any.whl to c:\program files\python38\lib\site -packages
Adding six 1.13.0 to easy-install.pth file
Installed c:\program files\python38\lib\site-packages\six-1.13.0-py3.8.egg
Finished processing dependencies for esptool==2.8
D:\Tmp\Tasmota\esptool-2.8>

 

 

 
A présent nous voici aux 4 grandes étapes du flashing.

ETAPE 1 : SAUVEGARDE DU FIRMWARE ACTUEL

C'est une étape que je vous invite à ne pas négliger car utile si l'on veut retourner sur le firmware d'origine.
Veuillez remplacer le port COM par celui que vous avez récupéreé dans l'une des étapes précédentes.
Noter auss ile nom Backup.bin : c'est le nom du fichier que je donne pour la sauvegarde de mon firmware actuel. Donnez-lui un nom plus pertinent ! ;o)

D:\Tmp\Tasmota\esptool-2.8>python esptool.py --port COM6 read_flash 0x00000 0x100000 Backup.bin

esptool.py v2.8

Serial port COM6

Connecting....

Detecting chip type... ESP8266

Chip is ESP8285

Features: WiFi, Embedded Flash

Crystal is 26MHz

MAC: 84:0d:8e:66:0e:0d

Uploading stub...

Running stub...

Stub running...

1048576 (100 %)

1048576 (100 %)

Read 1048576 bytes at 0x0 in 98.7 seconds (85.0 kbit/s)...

Hard resetting via RTS pin...

 

 

=> Déconnecter l'USB de l'ordinateur et reconnecter en maintenance le bouton poussoir pendant 2s


ETAPE 2 : SUPPRESSION DU FIRMWARE ACTUEL

Etape décisive qui va nettoyer complètement le firmware actuellement présent sur votre matériel !
(comme précédement remplacer le port COM6 par le vôtre)

D:\Tmp\Tasmota\esptool-2.8>esptool.py --port COM6 erase_flash

esptool.py v2.8

Serial port COM6

Connecting....

Detecting chip type... ESP8266

Chip is ESP8285

Features: WiFi, Embedded Flash

Crystal is 26MHz

MAC: 84:0d:8e:66:0e:0d

Uploading stub...

Running stub...

Stub running...

Erasing flash (this may take a while)...

Chip erase completed successfully in 2.9s

Hard resetting via RTS pin...

 

 

=> Déconnecter l'USB de l'ordinateur et reconnecter en maintenance le bouton poussoir pendant 2s

 

ETAPE 3 : ECRITURE DU FIRMWARE TASMOTA

Encore une fois, positionner le bon port COM et le bon nom de fichier que vous avez téléchargé précédement.
Patientez car cela prend un peu plus d'une minute.

D:\Tmp\Tasmota\esptool-2.8>esptool.py --port COM6 write_flash -fs 1MB -fm dout 0x0 sonoff-FR.bin

esptool.py v2.8

Serial port COM6

Connecting....

Detecting chip type... ESP8266

Chip is ESP8285

Features: WiFi, Embedded Flash

Crystal is 26MHz

MAC: 84:0d:8e:66:0e:0d

Uploading stub...

Running stub...

Stub running...

Configuring flash size...

Compressed 578864 bytes to 398905...

Wrote 578864 bytes (398905 compressed) at 0x00000000 in 35.5 seconds (effective

130.6 kbit/s)...

Hash of data verified.

Leaving...

Hard resetting via RTS pin...

D:\Tmp\Tasmota\esptool-2.8>

 

NOTA

A noter qu'il existe aussi des outils qui peuvent aider comme NodeMCU PYFlasher qui evite les commandes.
Si vous l'utilisez, parametrer ainsi ;

nodemcu2

 

=> Déconnecter l'USB de l'ordinateur.
Vous pouvez aussi à présent repositionner le commutateur qu'il faut à présent positionner en s'éloignant du rectangle rouge ainsi afin que le Sonoff se mette en mode fontionnement.

ETAPE 4 : DEMARRAGE DU SONOFF BRIDGE RF 433

Cette fois si on débranche les connecteurs FDTI au composant Sonoff et on alimente la carte Sonoff au port USB de l'ordinateur par exemple.

Configuration du reseau WIFI

Utilisez votre smartphone ou une tablette/ordi pour chercher un réseau WIFI qui devrait apparaitre.
Chez moi c'était du type "Sonoff-3597" ou tasmota-6976

Vous sélectionnez ce réseau pour vous connecter dessus.
A présent il faut utiliser un navigateur web pour se connecter à l'IP de l'appareil Sonoff.
Tapez l'IP suivante : 192.168.4.1

Vous obtiendrez une page ainsi :

ip
Cette page permet la définition de votre réseau WIFI et d'un réseau secondaire (optionnel) pour que le firmware Tasmota puisse communiquer.

Vous pouvez cliquer sur "Scan des réseaux WIFI" il vous proposera ainsi un réseau wifi qu'il détecte.

Ensuite :

AP1 SSID : c'est le nom du reseau WIFI principal
Mot de passe AP1 : c'est le password de votre reaseau WIFI princiapl
AP2 SSID : c'est le nom du reseau WIFI secondaire (utilse si vous avez un pb avec vote reseau principal).
Tout le monde conseil de mettre son nom de reseau en point d'accès mobile de votrer smartphone au cas où votre wifi principal ne fonctionnerait plus.
Ne soyez pas surpris que dans le titre il y ait de marqué Sonoff basic : vous n'avez pas encore configuré le type de sonoff.

Enregistrer.

Il va se relancer tout seul.

Configuration du modèle

A présent il faut utiliser un navigateur web pour se connecter à l'IP de l'appareil Sonoff configuré sur votre réseau.

Pour connaitre l'IP assigné, utiliser un outil qui scanne les IP de votre réseau.
Chez moi le sonoff était situé sur l'IP :  192.168.0.18
Tapez cette ip dans votre naivateur et vous arrivez dans le beau menu de configuration de Tasmota !

Par défaut le firmware défini par défaut le modèle BASIC du sonoff.
Aller dans configuration et paramètre du module.

menu1

 

Nous nous avons le modèle Sonoff RF que l'on selectionne : Sonoff Bridge (25)

 

menu2

Enregistrez.

Attendez quelques secondes que votre module redémarre dans la bonne configuration.



Configuration de MQTT

Vous avez presque fini.
Il reste juste maintenant la configuration MQTT, primordiale pour dialoguer dans openHAB
On retourne dans Configuration

menu3

puis Configuration MQTT
Hote = IP de openHAB
Port = port de MQTT 
Utilisateur : user de MQTT
PAssword = mote de passe de votre MQTT
Topic : le label MQTT qui sera interprété (cf config openHAB ci-dessous)

menu4 

Puis on sauvegarde !
A présent votre module peut dialoguer avec MQTT. Vous pouvez aller dans le menu Tasmota et alelr dans console, vous verrez la log de connection à MQTT apparaitre avec votre configuration !


FIN - Dans openHAB !!

Tout d'abord on cree un fichier de type things.

mqtt.things dans lequel on positionee la configuration de notre sonoff rf Bridge :
Avec le port de votre mqtt (souvent 1883), l'IP de votre openHAB, le user et le password.
Le nom SonoffRFBridge correspond au nom que vous avez donné dans la configuration de votre module sous Tasmota (configuration MQTT du chapitre précédent)

ATTENTION !!! La création du broker doit déjà avoir été faite auparavant sous openHAB via le PaperUI !

// MQTT - All Things Definitions
Bridge mqtt:broker:embedded-mqtt-broker "MQTT Broker" [ host="192.168.0.xx", port=1883, secure="AUTO", username="monuser", password="monpassword" ]
{
    // Modèle : Sonoff RF 433 Bridge
    Thing mqtt:topic:SonoffRFBridge "SONOFF RF Bridge" @ "RDC"
    {
        Channels:
        Type string : reachable     "Reachable"            [ stateTopic="tele/SonoffRFBridge/LWT" ]
        Type string : recieveddata  "Received Data"        [ stateTopic="tele/SonoffRFBridge/RESULT", transformationPattern="JSONPATH:$.RfReceived.Data" ]
        Type string : recievedsync  "Received Sync"        [ stateTopic="tele/SonoffRFBridge/RESULT", transformationPattern="JSONPATH:$.RfReceived.Sync" ]
        Type string : recievedlow   "Received Low"         [ stateTopic="tele/SonoffRFBridge/RESULT", transformationPattern="JSONPATH:$.RfReceived.Low" ]
        Type string : recievedhigh  "Received High"        [ stateTopic="tele/SonoffRFBridge/RESULT", transformationPattern="JSONPATH:$.RfReceived.High" ]
        Type string : recievedrfkey "Received RfKey"       [ stateTopic="tele/SonoffRFBridge/RESULT", transformationPattern="JSONPATH:$.RfReceived.RfKey" ]
        Type switch : button1       "Bouton 1"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY1", transformationPattern="JSONPATH:$.RfKey1" ]
        Type switch : button2       "Bouton 2"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY2", transformationPattern="JSONPATH:$.RfKey2" ]
        Type switch : button3       "Bouton 3"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY3", transformationPattern="JSONPATH:$.RfKey3" ]
        Type switch : button4       "Bouton 4"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY4", transformationPattern="JSONPATH:$.RfKey4" ]
        Type switch : button5       "Bouton 5"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY5", transformationPattern="JSONPATH:$.RfKey5" ] 
        Type switch : button6       "Bouton 6"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY6", transformationPattern="JSONPATH:$.RfKey6" ]
        Type switch : button7       "Bouton 7"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY7", transformationPattern="JSONPATH:$.RfKey7" ]
        Type switch : button8       "Bouton 8"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY8", transformationPattern="JSONPATH:$.RfKey8" ]
        Type switch : button9       "Bouton 9"             [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY9", transformationPattern="JSONPATH:$.RfKey9" ]
        Type switch : button10      "Bouton 10"            [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY10", transformationPattern="JSONPATH:$.RfKey10" ]
        Type switch : button11      "Bouton 11"            [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY11", transformationPattern="JSONPATH:$.RfKey11" ]
        Type switch : button12      "Bouton 12"            [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY12", transformationPattern="JSONPATH:$.RfKey12" ]
        Type switch : button13      "Bouton 13"            [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY13", transformationPattern="JSONPATH:$.RfKey13" ]
        Type switch : button14      "Bouton 14"            [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY14", transformationPattern="JSONPATH:$.RfKey14" ]
        Type switch : button15      "Bouton 15"            [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY15", transformationPattern="JSONPATH:$.RfKey15" ]
        Type switch : button16      "Bouton 16"            [ stateTopic="stat/SonoffRFBridge/RESULT", commandTopic="cmnd/SonoffRFBridge/RFKEY16", transformationPattern="JSONPATH:$.RfKey16" ]
        Type number : rssi          "WiFi Signal Strength" [ stateTopic="tele/SonoffRFBridge/STATE", transformationPattern="JSONPATH:$.Wifi.RSSI" ]
    }
   // Ici se rajouteront vos composants de type 433
}


Pour terminer on cree un fichier de type items :
bridge.items

// SONOFF RF BRIDGE 433
String Sonoff_RF_Reachable      "Reachable: [%s]"                <contactable>   (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:reachable"}
String Sonoff_RF_Received_Data  "Received Data: [%s]"            <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:recieveddata"}
String Sonoff_RF_Received_Sync  "Received Sync: [%s]"            <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:recievedsync"}
String Sonoff_RF_Received_Low   "Received Low: [%s]"             <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:recievedlow"}
String Sonoff_RF_Received_High  "Received High: [%s]"            <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:recievedhigh"}
String Sonoff_RF_Received_RfKey "Received RfKey: [%s]"           <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:recievedrfkey"}
Switch Sonoff_RF_Button_1       "Bouton 1"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button1", autoupdate="false"}
Switch Sonoff_RF_Button_2       "Bouton 2"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button2", autoupdate="false"}
Switch Sonoff_RF_Button_3       "Bouton 3"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button3", autoupdate="false"}
Switch Sonoff_RF_Button_4       "Bouton 4"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button4", autoupdate="false"}
Switch Sonoff_RF_Button_5       "Bouton 5"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button5", autoupdate="false"}
Switch Sonoff_RF_Button_6       "Bouton 6"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button6", autoupdate="false"}
Switch Sonoff_RF_Button_7       "Bouton 7"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button7", autoupdate="false"}
Switch Sonoff_RF_Button_8       "Bouton 8"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button8", autoupdate="false"}
Switch Sonoff_RF_Button_9       "Bouton 9"                       <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button9", autoupdate="false"}
Switch Sonoff_RF_Button_10      "Bouton 10"                      <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button10", autoupdate="false"}
Switch Sonoff_RF_Button_11      "Bouton 11"                      <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button11", autoupdate="false"}
Switch Sonoff_RF_Button_12      "Bouton 12"                      <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button12", autoupdate="false"}
Switch Sonoff_RF_Button_13      "Bouton 13"                      <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button13", autoupdate="false"}
Switch Sonoff_RF_Button_14      "Bouton 14"                      <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button14", autoupdate="false"}
Switch Sonoff_RF_Button_15      "Bouton 15"                      <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button15", autoupdate="false"}
Switch Sonoff_RF_Button_16      "Bouton 16"                      <none>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:button16", autoupdate="false"}
Number Sonoff_RF_RSSI           "WiFi Signal Strength [%d %%]"   <wifi>          (gSonoff_RF) { channel="mqtt:topic:SonoffRFBridge:rssi" }


A présent votre configuration de Sonoff bridge et terminé !
(n'oubliez pas de remonter complètement le module ;o)


Ce tutoriel devenait nécesaire car je vous ai montré dans un autre tutoriel comment flasher des appareils avec le protocol Tuya.
Cependant cela ne fonctionne pas pour tous les cas.
En effet, suivant le composant électronique utilisé par le fabricant cette méthode ne peut être appliquée. (notemment quand le matériel ne se base pas sur un ESP82xx)
Je vais vous décrire ici une manière stable et fiable pour ne pas passer par un logiciel propriétaire mais que cela soit bien openHAB qui gère votre matériel.

 

Tuya via MQTT sans flasher !

L'exemple avec une lampe

Je vais m'appuyer sur la mise en oeuvre d'une lampe multicouleur du magasin "Action" qui vend cette ampoule connectée sous la marque LSC Smart Connect
La référence est la suivante : White and Color ambiance Smart LED (806 lumen 9 watt / vis de type E27)
Vous pouvez la trouver ici au prix de : 8€95
https://www.action.com/fr-fr/p/ampoule-led-multicolore-connectee-lsc-smart-connect-2/

Image sans titre3

Cette ampoule fonctionne sous WIFI avec le logiciel "LSC Smart Connect" que vous pouvez trouver sur Google Play ici :
https://play.google.com/store/apps/details?id=com.lscsmartconnection.smart
J'ai essayé vainement de la flasher avec Tasmota... impossible. L'équipe Tasmota confirme qu'elle ne pourra pas permttre un flashage de ces produits avec ces composants...


Pourquoi chercher à forcer l'utilisation de MQTT ?

Avant toute chose, pourquoi chercher à faire ces... bidouilles alors que finalement les constructeurs d'ampoules s'embêtent à développer des logiciels spécifiques qui font très bien leur travail ?
2 raisons majeures :
- Actuellement vu le nombre de protocoles et de logiciels différents : soit vous êtes cantonnés à utiliser la même marque et dépendre de ce protocol et des produits liés, soit vous avez plein de logiciels propriétaires (mais alors c'est pas pratique !)
ou alors vous cherchez à avoir un matériel adapté avec des coûts moindre mais surtout un suivi centralisé. Ca c'est le rôle d'openHAB. Mais openHAB a besoin de dialoguer avec des connecteurs de protocoles standards et pas de protocoles propriétaires...
MQTT est un protocole standard pratique avec du WIFI.
- Autre raison : quand vous utilisez ces logiciels propriétaires vous remarquerez qu'en traçant leur 'route' ils passent pas des serveurs amazon (AWS j'imagine) et derrière ils collectent des statistiques. Perso j'aime pas ça. Beurk.

 

Un binding Tuya existe !

Pour être le plus complet possible, il existe un "binding" qui sait gérer le matériel Tuya. Certes vous ne le trouverez pas dans les binding dispo dans openHAB.
Il a été développé par Wim Wissers. Mais malheureusement dû à des problèmes de stabilité, et ne trouvant pas la raison, il a décidé de ne pas poursuivre.
https://github.com/wvissers/openhab2-addons-tuya

Je vous engage à le tester.
Personnellement je l'ai testé et j'ai en effet eu quelques problèmes de stabilité au bout de quelques jours.
L'auteur du developpement du connecteur m'a confirmé qu'il abandonnait le projet donc il me fallait trouver une solution plus stable.


Le process Tuya MQTT via nodejs : notre sauveur !

Petite synthèse du principe :
Par un service permanent qui tourne sur le système, le module de type nodejs va analyser et générer des trames directement avec le composant.
La difficulté majeure est d'obetnir les identifiants uniques qui permettront de communiquer avec le produit.
Ensuite ce module va générer des ordrese et communiquer avec.
L'autre astuce est de pinger régulièrement le produit pour être "à l'écoute" de celui-ci.

Comme d'habitude, j'aime citer les personnes qui ont eu l'intelligence de permettre ceci :
Voici le programme initial : https://github.com/codetheweb/tuyapi
Qui a été ensuite retouché pour mieux coller au besoin de service Linux qui tournera de ce fait très bien pour openHAB :
https://github.com/codetheweb/tuyapi

Deux prérequis
- Il est nécessaire à cette installation d'avoir MQTT déjà installé et opérationnel dans openHAB.
- L'aurte chose à faire est de paramétrer aussi l'IP de votre lampe sur votre routeur afin qu'il ait une IP fixe.
En effet, le lien MQTT via réseau se fera sur une IP fixe. (si vous ne savez pas le MAC ID + IP de votre matériel, je vous indiquerai dans le tutoriel à quel moment vous pouvez les récupérer)



ETAPE 1 : L'installation

Aller dans le répertoire où se situe les définitions des items/things etc... et ce qui nous interesse aujourd'hui, les scripts.

cd /etc/openhab2/scripts

 

A présent il faut que vous ayez le programme Git d'installé.
Si ce n'est pas le cas, passez la commande :

sudo apt-get install git

 

Une fois Git installé nous allons récupérer la dernière version 3.3 de tuya-mqtt :

sudo git clone https://github.com/tsightler/tuya-mqtt.git

 

Ensuite, allons dans le répertoire pour installer nodejs via le package manager de nodejs NPM (Node Package Manager) :

cd tuya-mqtt
sudo npm install

 

 

ETAPE 2 : La configuration

Le fichier à configurer se nomme config.json, on se base sur le fichier modèle.

sudo cp config.json.sample config.json

Voici un exemple de contenu du fichier config.json que vous pouvez éditer en faisant :

sudo vi config.json

{
"host": "192.168.0.18",                                             adresse IP de votre MQTT installé dans openHAB
"port": 1883,                                                             port de votre MQTT installé dans openHAB
"topic": "tuya/",                                                         nom du topic que vous trouverez dans MQTT installé dans openHAB
"mqtt_user": "usermqtt",                                          user de connexion à votre MQTT installé dans openHAB
"mqtt_pass": "passwordmqtt",                                 password de connexion à votre MQTT installé dans openHAB
"qos": 2                                                                    c'est le QualityOfService pour le broker
}

 
Sauvegarder ce fichier de configuration.



ETAPE 3 : Paramétrer le nodejs dans votre système

Pourquoi a-t-on besoin de faire cela ?
Il serait peu pratique de devoir lancer manuellement ce process nodejs à chaque fois que vous redémarrez votre système d'exploitation... Ce serait mieux que cela soit un process permanent et donc... un service.
Si vous avez déjà ce process nodejs qui tourne, n'oubliez pas de le killer avant :

sudo ps aux | grep node
sudo kill -9 process_id_que_vous_avez_recuperez_avant

 
Création du service :

cd /etc/systemd/system
sudo vi tuyaapi-mqtt.service

 

Voici le contenu du fichier :

#!/bin/sh -
[Unit]
Description=tuyaapi-mqtt

[Service]
ExecStart=/usr/bin/node /etc/openhab2/scripts/tuya-mqtt/tuya-mqtt.js
Restart=always
User=openhab
Group=openhab
Environment=PATH=/usr/bin/
Environment=NODE_ENV=production
WorkingDirectory=/usr/bin/

[Install]
WantedBy=multi-user.target
Alias=tuyaapi-mqtt.service

 

Positionner les droits sur ce fichier :

sudo chown root:root /etc/systemd/system/tuyaapi-mqtt.service
sudo chmod 666 /etc/systemd/system/tuyaapi-mqtt.service

 
On active le service et le symlink va être créé :

sudo systemctl daemon-reload
sudo systemctl enable tuyaapi-mqtt.service

 

 On démarre le service à présent créé :

sudo systemctl start tuyaapi-mqtt.service



Quelques autres commandes utiles...


a. Evidemment si vous souhaitez arrêter le service, la commande est :

sudo systemctl stop tuyaapi-mqtt.service



 

b. Pour savoir le status :

sudo systemctl status tuyaapi-mqtt.service



 

c. Pour le redemarrer :

sudo systemctl restart tuyaapi-mqtt.service



 

d. Pour le démarrer en mode DEBUG :

DEBUG=* /usr/bin/node /etc/openhab2/scripts/tuya-mqtt/tuya-mqtt.js

 

 



ETAPE 4 : Identifier l'ID et la clé de la lampe

Le but est d'avoir ces infos pour permettre de communiquer via MQTT.
Avec ces infos on pourra ensuite configurer le composant "Thing" dans openHAB.

1. Pour trouver ces infos, il faut tout d'abord installer sur votre smartphone le logiciel standard du produit (dans le cas de ma lampe c'est LSC Smart Connection : https://play.google.com/store/apps/details?id=com.lscsmartconnection.smart&hl=fr)
Configurer la lampe de manière standard jusqu'à ce que vous puissiez commander la lampe via ce logiciel.
Donc vérifiez bien que via le logiciel standard vous pouvez commander votre lampe.

Nous allons à présent récupérer la première info qui nous est nécessaire :
Allez sur votre lampe (toujorus dans le logiciel, sélectionnez "menu" puis allez sur "Informations appareil"
Là nous avons notre première valeur importante : l'ID virtuel (Virtual ID)
Il nous reste la clé à obtenir.

2. Maintenant, installez le logiciel sur votre smartphone pour capter les Trames de votre réseau qui s'intitule "Package Capture" via Google Play : https://play.google.com/store/apps/details?id=app.greyshirts.sslcapture&hl=fr

3. Au premier lancement du logiciel il demandera pour installer un certificat, il est nécessaire de l'accepter pour poursuivre

4. En haut il y a 2 symbols de type "Lecture". Cellui qui a un symbol avec une flèche permet de capturer les Trames d'une application précise.

5. Sélectionner ce symbol puis choisissez l'application précédement installée "LSC Smart Connect" de votre Smartphone de la liste de vos applis.

6. La capture des trames commence.
Cela signifie que toute action sera capturée et donc en récupérant ces infos on va récupérer l'info qui nous manque : le "localkey"
Toujours sur votre smartphone, retournez (en parallele) sur le logiciel LSC et faites une action d'allumage + éteindre.

Retournez sur le logiciel de capture de trames et appuyez sur le bouton de stop de capture et reperez en dessous les quelques logs de générées.
Dans l'une d'entre elles qui sont de type SSL vous verrez une mise en forme de type fichier json : vous allez repérer notre valeur "localkey" recherchée !

Notez la bien car cela va nous être utile pour la configuration dans openHAB : on a à présent tout pour prendre la main via openHAB.

Screenshot1
ETAPE 5 : la configuration dans openHAB

Je rappelle qu'il faut que vous ayez installé et configuré MQTT dans openHAB.
La configuration est à faire pour définir tout d'abord le "Thing" puis les "Items".

Exemple de Thing à placer à l'intérieur de votre Bridge mqtt broker :

    Thing mqtt:topic:TuyaLampe2 "TUYA LAMPE 2" @ "RDC"
    {
       Channels:
       Type switch : TuyaLampe2Switch "Tuya Lampe 2" [ stateTopic="tuya/ver3.3/virtualID/localKey/adresseIPFixeLampe/state", commandTopic="tuya/ver3.3/virtualID/localKey/adresseIPFixeLampe/command",on="1",off="0" ]
       Type switch : TuyaLampe2_GET_MQTT "Reading Bulb MQTT STATUS Channel" [ stateTopic="tuya/ver3.3/virtualID/localKey/adresseIPFixeLampe/command", one="{ \"dps\": 7, \"set\": false }", off="{ \"dps\": 7, \"set\": false }" ]
       Type colorHSB : TuyaLampe2Color "Tuya Lampe 2 Color" [ stateTopic="tuya/ver3.3/virtualID/localKey/adresseIPFixeLampe/state", commandTopic="tuya/ver3.3/virtualID/localKey/adresseIPFixeLampe/color" ]
    }
Ce qui est en gras est à remplacer (voir les chapitres ci-dessus) : virtualID, localKey, adresseIPFixeLampe
Attention à bien respecter la syntaxe !

Exemple d'items

Switch TuyaLampe_2 "Tuya Lampe 2" <light> { channel="mqtt:topic:TuyaLampe2:TuyaLampe2Switch" }
Color TuyaLampe_2_Color "Tuya Lampe 2 Color" { channel="mqtt:topic:TuyaLampe2:TuyaLampe2Color" }


 

 

ETAPE 6 : Une relance openHAB et c'est fini !

Cette étape est très importante !! Toute action/modification des définitions d'items ou de thing dans openHAB nécessite un A/R de openHAB !
De plus, toute nouvelle réinitialisation de votre lampe nécessitera de rechercher son nouveau localKey et donc de reparamétrer le Thing dans openHAB.

Pour relancer openHAB tapez cette commande :

sudo systemctl restart openhab2.service

 



Une fois openHAB redémarré, vous pouvez vérifier que cela fonctionne via PaperUI ou sur votre entrée smartphone d'openHAB.

Have fun !