[TUTO] Partage d'informations entre BASH et Gladys

Bonjour,

je vous propose 2 TUTO qui expliquent comment utiliser des commandes BASH pour envoyer des données à Gladys et pour en recevoir.

BASH est simple à utiliser et est présent dans beaucoup de GNU/Linux (comme Raspberry) et sera de toute façon reproductible pour un autre SHELL.
Il permet d’exécuter n’importe quel commande système et de gérer tout le pc.

Pour communiquer, il faut utiliser le protocole MQTT.
Gladys propose très gentiment d’installer un brocker MQTT en un clic via Intégration > MQTT > Configuration > Utiliser un broker dans un conteneur Docker.

Une fois installé, on peut créer des appareils via Intégration > MQTT > Appareils > Nouveau.


TUTO n°1 : Afficher la température du Raspberry dans Gladys.
L’idée est donc de récupérer via un script BASH la température du Raspberry et de l’envoyer à Gladys.


Côté Gladys :

  1. Création de l’appareil :
    Nom : Température Raspberry
    Id externe : mqtt:Salle:RaspTemp (mqtt:Pièce:Élément)
    Pièce : Salle

  2. **Ajout d’une fonctionnalité de type : **
    Nom : Température Raspberry
    ID externe de la fonctionnalité : mqtt:RaspTemp:temp (mqtt:Élément:Fonction)
    Unité : C°
    Valeur min : 0 (pour atteindre cette température, vous le refroidissez à l’azote…)
    Valeur max : 110 (parfait pour l’utiliser comme chauffage)
    Conserver l’historique des états : Oui
    Est-ce un capteur : Oui
    Topic MQTT pour publier : Vous pouvez vous mettre de côté le topic qui servira plus loin.

  3. Ajout de l’appareil sur le tableau de bord :

Rien de spécifique ici, il faut procéder comme d’habitude.

Voilà, on en a terminé avec Gladys :slight_smile:


Côté BASH :
Passons aux scripts BASH que je vais mettre dans /opt/mosquittos/ (ou autre emplacement de votre choix mais il faudra adapter les adresses).

Je commente un maximum tout le code afin qu’il soit le plus compréhensible possible, n’hésitez pas à le lire.

  1. Création d’un script commun /opt/mosquitto/MQTTConfig.sh :

Il sera importé par les autres (différents TUTO), il contient :
Une fonction testant les commandes nécessaires et les paquets à installer (pour ubuntu) le cas échéant.
Les identifiants de connexion au brocker MQTT créé par Gladys accessibles via Intégration > MQTT > Configuration.
Des variables pour colorer l’affichage des retours.

#!/bin/bash

#############################################
## Fichier à sourcer dans les scripts MQTT ##
#############################################

### Variables à personnaliser
# Connexion au brocker MQTT
User="gladys"
Pass="XYZ"
### Variables à personnaliser


function CommandCheck()
{
    # Fonction vérifiant la présence des commandes nécessaires
    # Paramètre : Nom de la commande et du paquet (facultatif) séparés par :
        # Ex : mosquitto_pub:mosquitto-clients

    # Si aucun paramètre n'est donné
    [[ -z ${1} ]] && return 1

    # Limitation des variables à la fonction
    local Command Package Parameter ReturnValue
    ReturnValue=0

    # Traite tous les paramètres
    for Parameter in "${@}"
    do
        Command="${Parameter%%:*}"
        Package="${Parameter##*:}"

        # Si la commande n'existe pas
        if ! which ${Command} &>/dev/null
        then
            # Valeur de retour à 1 pour afficher tous les echo avant de stopper
            ReturnValue=1

            echo -e "[${ROUGE}Erreur${RAZ}] Arrêt du script car la commande ${BLEUFONCE}${Command}${RAZ} est introuvable." 1>&2

            # Si un paquet est donné
            [[ ${Package} ]] && echo -e "Pour ubuntu : ${FUCHSIA}sudo apt-get install ${Package}${RAZ}" 1>&2
        fi
    done

    return ${ReturnValue}
}

# Couleurs pour l'affichage des retours
FUCHSIA="\e[1;35m"
RAZ="\e[m"
BLEUFONCE="\e[1;34m"
ROUGE="\e[1;31m"
ORANGE="\e[1m\[\e[38;5;202m\]"

Il n’y que les variables entre ### Variables à personnaliser à adapter.

  1. Création du script /opt/mosquitto/BashToGladys.sh :

Son but est de récupérer la température du Raspberry à interval régulier et d’envoyer cette information à Gladys.

#/bin/bash

###################################################
## Envoi de la température du Raspberry à Gladys ##
###################################################

### Variables à personnaliser
# Nombre de seconde entre les récupération de température
# Une petite valeur n'est pas une très bonne idée...
TimeOut=60

# Adresse du topic de l'appareil
# Disponible dans Gladys > Intégration > MQTT > Appareils > Température Raspberry > Température > Topic MQTT pour publier
Topic="gladys/master/device/mqtt:Salle:RaspTemp/feature/mqtt:RaspTemp:temp/state"
### Variables à personnaliser

# Chargement du fichier commun
source /opt/mosquitto/MQTTConfig.sh

# Vérification de la présence des commandes qui si absentes provoquent l'arrêt du script
# Nécessite la commande mosquitto_pub du paquet mosquitto-clients
! CommandCheck "mosquitto_pub:mosquitto-clients" && exit 1

# Bloque le script si le TimeOut est inférieur à 1
if [[ ${TimeOut:-0} -lt 1 ]]
then
    echo -e "[${ROUGE}Erreur${RAZ}] Le TimeOut est inadapté." 1>&2
    exit 1
fi

# Boucle infinie
while true
do
    # Récupération de la température du Raspberry
    Temperature=$(/usr/bin/vcgencmd measure_temp)
    Temperature=${Temperature//[^0-9.]/}

    # Si la variable n'est pas vide
    if [[ ${Temperature} ]]
    then
        # Affichage de l'info dans le SHELL
        echo -e "[${FUCHSIA}$(date +'%x %X')${RAZ}] La température du Raspberry est de ${BLEUFONCE}${Temperature}°c${RAZ}."

        # Envoi de l'information à Gladys avec mosquitto_pub
        # -u User : Utilisateur pour la connexion au brocker MQTT, provient du fichier MQTTConfig.sh
        # -P Pass : Mot de passe pour la connexion au brocker MQTT, provient du fichier MQTTConfig.sh
        # -t Topic : Adresse du Topic de l'appareil créé dans Gladys, définit en début de script
        # -m Temperature : Utilisation de la température
        mosquitto_pub -u "${User}" -P "${Pass}" -t "${Topic}" -m "${Temperature}"

        # Récupération de la valeur retour de la commande mosquitto_pub
        MosquittoReturns=${?}

        # Affichage du code erreur de mosquitto si code retour > 0
        (( ${MosquittoReturns} )) && echo -e "[${ROUGE}Erreur${RAZ}] La commande mosquitto_sub a renvoyé le code ${MosquittoReturns}." 1>&2

    # Si la variable de température est vide
    else
        # Affichage d'un message d'erreur
        echo -e "[${ROUGE}Erreur${RAZ}] Température non récupérée." 1>&2
    fi

    # Pause du script le temps demandé
    sleep "${TimeOut}"
done

Il n’y que les variables entre ### Variables à personnaliser à adapter.

  1. Exécution du script :

Il suffit de faire un simple :

bash /opt/mosquitto/BashToGladys.sh

Avec un TimeOut de 60 secondes, il affiche alors :

[16/02/2023 10:35:05] La température du Raspberry est de 39.4°c.
[16/02/2023 10:36:05] La température du Raspberry est de 40.4°c.
[16/02/2023 10:37:05] La température du Raspberry est de 40.4°c.
[16/02/2023 10:38:05] La température du Raspberry est de 39.9°c.

Et la valeur est bien mise à jour dans Gladys.

Si la commande mosquitto_pub n’existe pas, le script affiche :

[Erreur] Arrêt du script car la commande mosquitto_pub est introuvable.
Pour ubuntu : sudo apt-get install mosquitto-clients

Si tout est fonctionnel, il ne reste plus qu’à exécuter le script au démarrage du Raspberry (crontab ou autre).

Limitation :
Il n’est possible d’envoyer que des nombres et des nombres à virgule à Gladys.
Envoyer du texte ne fonctionne pas, aucune erreur n’est émise mais rien ne s’affiche.


Autres tuto :

TUTO n°2 : Lancer une commande BASH via à une action Gladys., dans le message ci dessous.

TUTO n°3 : Indiquer la présence d’un utilisateur via le WI-FI de son téléphone.

TUTO n°4 : Gestion de son robot aspirateur sous Valetudo dans Gladys.

5 Likes

TUTO n°2 : Lancer une commande BASH via à une action Gladys.
L’idée est de surveiller le topic d’un appareil Gladys depuis BASH et d’exécuter les commandes adéquates.


Côté Gladys :

  1. Création de l’appareil :
    Nom : Appel BASH
    Id externe : mqtt:Salle:AppelBASH
    Pièce : Salle

  2. Ajout d’une fonctionnalité de type Clic bouton (par exemple) :
    Nom : Appel BASH
    ID externe de la fonctionnalité : mqtt:AppelBASH:Action
    Valeur min : 0
    Valeur max : 9 (Permettra 10 actions différentes)
    Conserver l’historique des états : Oui
    Est-ce un capteur : Non
    Topic MQTT à écouter : Vous pouvez vous mettre de côté le topic qui servira plus loin.

  3. Définir une scène :
    Déclencheur : Celui de votre choix (comme le changement d’état d’un vrai bouton par exemple).
    Action : Contrôler un appareil.
    Appareil : Appel BASH
    Valeur : 1 (entre 0 et 9)

Il ne restera plus qu’à déclencher la scène une fois les scripts BASH terminés.


Côté scripts BASH.

  1. Reprise du script commun /opt/mosquitto/MQTTConfig.sh du TUTO n°1.

  2. Création du script /opt/mosquitto/GladysToBash.sh :
    Il sera à l’écoute du topic de l’appareil créé dans Gladys.

#!/bin/bash

#####################################################################
## Surveillance d'un topic Gladys avec execution de commandes BASH ##
#####################################################################

### Variables à personnaliser
# Il faut personnaliser le CASE de la boucle WHILE.

# Adresse du topic de l'appareil
# Disponible dans Gladys > Intégration > MQTT > Appareils > Appel BASH > Clic Bouton > Topic MQTT à écouter
Topic="gladys/device/mqtt:salle:AppelBASH/feature/mqtt:AppelBASH:Action/state"
### Variables à personnaliser

# Chargement du fichier commun
source /opt/mosquitto/MQTTConfig.sh

# Nécessite la commande mosquitto_sub du paquet mosquitto-clients
! CommandCheck "mosquitto_sub:mosquitto-clients" && exit 1

echo "Le script attend de recevoir les commandes de Gladys." 1>&2
echo "Il ne rend la main que si des break et exit sont intégrés à la boucle while." 1>&2

# Boucle écoutant en permanence le topic de l'appareil de Gladys
# -u User : Utilisateur pour la connexion au brocker MQTT, provient du fichier MQTTConfig.sh
# -P Pass : Mot de passe pour la connexion au brocker MQTT, provient du fichier MQTTConfig.sh
# -t Topic : Adresse du Topic de l'appareil créé dans Gladys, définit en début de script
# Récupération des retours dans la variable Value
while read Value
do
    # Saut de traitement si Value n'est pas comprise entre 0 et 9
    if [[ "${Value}" != [0-9] ]]
    then
        echo -e "[${ORANGE}Attention${RAZ}] Valeur ${Value} inconnue..." 1>&2
        continue
    fi

    echo -e "[${FUCHSIA}$(date +'%x %X')${RAZ}] Exécution de la commande n°${Value}."

    # Case servant à réaliser la bonne action en fonction de Value
    # Utilisation d'echo pour ne pas vraiment exécuter les commandes avec ce TUTO
    case "${Value}" in
        # Reboot du Raspberry
        0) echo sudo reboot ;;

        # Réveil d'un pc via WakeOnLine en arrière plan pour ne pas bloquer la boucle
        1) echo wakeonlan XX:YY:ZZ:ZZ:YY:XX & ;;

        # Lancement d'une alarme via un fichier wav dans vlc en arrière plan pour ne pas bloquer la boucle
        2) echo vlc "/opt/alarme.wav" & ;;

        # Kill de toutes les commandes vlc
        3) echo killall vlc ;;

        # Toutes autres actions de votre choix...
        [3-9]) echo "Réalisation de l'action ${Value}.";;
    esac
done < <(mosquitto_sub -u "${User}" -P "${Pass}" -t "${Topic}")

Il faut adapter les variables entre ### Variables à personnaliser ainsi que les actions dans le case de la boucle while.

Pour info, il est possible de préciser le nombre de retour attendu par mosquitto_sub avant qu’il rende la main :

mosquitto_sub -u "${User}" -P "${Pass}" -t "${Topic}" -C x # Où x vaut le nombre de retour
  1. Exécution du script :

Il suffit d’appeler le script via un simple :

bash /opt/mosquitto/GladysToBash.sh

Le script ne rend pas la main sur le prompt, c’est normal, la boucle est infinie.
Il affiche :

Le script attend de recevoir les commandes de Gladys.
Il ne rend la main que si des break et exit sont intégrés à la boucle while.

  1. Exécution de la scène voulue depuis Gladys :

Rien de particulier ici, il suffit d’exécuter la scène manuellement ou via un autre appareil.
Le shell affiche alors :

[16/02/2023 11:35:05] Exécution de la commande n°5.
[16/02/2023 11:35:55] Exécution de la commande n°2.
[16/02/2023 11:45:55] Exécution de la commande n°3.

Si tout est fonctionnel, il ne reste plus qu’à exécuter le script au démarrage du Raspberry.


Autres tuto :

TUTO n°1 : Afficher la température du Raspberry dans Gladys.

TUTO n°3 : Indiquer la présence d’un utilisateur via le WI-FI de son téléphone.

TUTO n°4 : Gestion de son robot aspirateur sous Valetudo dans Gladys.

7 Likes

Super tout ça ! Super taff et super explications merci beaucoup !!! :+1:

Merci pour ta contribution @Hizo ! :pray: Super tuto :slight_smile:

Merci @Hizo ça me sera bien utile, j’avais envie de pouvoir faire ça sans en avoir eu le temps.
:pray::pray:

Vu le temps que ça m’a pris pour piger le fonctionnement (je suis un peu lent d’esprit…),
je me suis dis que ça permettrait sûrement à d’autre de gagner du temps.

Et c’est une façon d’apporter ma pierre à l’édifice à ce bon programme.

Et tant que Linuxien, c’est aussi une façon de rendre ce que les gens me donnent.

En tout cas, n’hésitez pas à me faire des retours si vous vous basez dessus.

Le TUTO 3 qui va pousser la complexité du bash est en stand-by tant que je ne sais pas afficher du texte.
C’est le seule élément bloquant mais important car ça représente la moitié des informations envoyées par l’aspirateur.

1 Like

Il faut créer ce type d’appareil dans le core, car on gère tout avec des constantes afin de standardiser ce que l’on stocke.

Exemple pour les boutons

Pour les aspirateurs robots on a des choses générique peut importe le modèle.

Statut : charging / idle / cleaning
Switch: on/off

Etc…

Bjr @Hizo,
J’ai suivi autant que j’ai pu la procédure indiquée mais lorsque je lance la commande:
bash /opt/mosquitto/BashToGladys.sh, j’ai ceci en retour:

: No such file or directory.sh: line 18: /opt/mosquitto/MQTTConfig.sh
/opt/mosquitto/BashToGladys.sh: line 22: CommandCheck: command not found
: numeric argument required.sh: line 22: exit: 1

J’ai déjà remédié à un grand nombre de messages d’erreurs en ajoutant de # à chaque saut de ligne mais là, mes connaissances en informatique ne me permettent pas de trouver ce qui bloque. :pensive:

Salut, es tu sur d’avoir bien fait :

Il te manque la fonction, fais une recherche sur la page à CommandCheck