[TUTO] Intégration de la Trottinette M365 dans Jeedom

[noodom]

Salut,

EDIT : tuto à suivre plus bas : viewtopic.php?f=157&t=47129&p=758618#p758618


Récent possesseur de la M365 (non pro), je l'ai pour l'instant fait reconnaitre dans le plugin BLEA.
Ca permet pour l'instant seulement de récupérer la présence.
Elle est reconnue comme un device inconu mais il suffirait d'ajouter la reconnaissance de "MIScooterXXXX" dans le plugin pour personnaliser son traitement : [DEBUG] : SCANNER------[(9, 'Complete Local Name', 'MIScooter5125')

Je ne l'exploite pas encore dans mon Jeedom car c'est faible comme récupération de données

L'idée serait en effet de récupérer sa présence 'retour à la maison' quand on arrive ou 'départ de la maison' quand on l'allume avant de partir).
Déjà possible avec l'intégration BLEA (comme j'ai précisé, pas testé en conditions réelles : j'ai juste vérifié qu'elle était reconnue et passait à présent/absent)

Par contre, une intégration plus poussée permettrait de récupérer le niveau de batterie pour des alertes, de récupérer le kilométrage pour une gestion de l'historique, ..)
- possible sous BLEA je pense (proposition remontée à sarakha63 mais pas de retour. J'ai voulu y jeter un oeil mais c'est tout sauf simple.. )
- par contre, sous Xiaomi Home, je ne sais pas ce que l'api remonte..

Des projets Github pour récupérer les infos existent déjà :
- https://github.com/AntonHakansson/m365py
- https://github.com/lukaville/mijia-scoo ... ngineering

A voir aussi la solution proposée par @benj29 (en se rapprochant de son intégration de la box APS) : viewtopic.php?f=157&t=47128&p=757588

Toute discussion/proposition pour faire avancer le sujet est ouverte !

[noodom]

Naïvement, en relisant la description de https://github.com/AntonHakansson/m365py ,
est-ce que ce genre d'intégration pourrait suffire ?

(Attention, seulement pour les trottinettes m365 avec le firmware 1.3.8 : très couramment utilisé suite à un flash de la trotinette pour améliorations)

ATTENTION : la proposition ci-dessous est juste une réflexion d'intégration dans Jeedom non testée et en aucun cas validée. A tester seulement en connaissance de cause !!

EDIT : suivre le tuto plus bas : viewtopic.php?f=157&t=47129&p=758618#p758618


- en ssh Jeedom, faire

Code : Tout sélectionner

pip install git+https://github.com/AntonHakansson/m365py.git#egg=m365py

- faire un script Jeedom pour récupérer l'adresse MAC automatiquement (ou la récupérer manuellement) pour l'enregistrer dans une variable par exemple

Code : Tout sélectionner

sudo python -m m365py 

- lancer le script de l'exemple pour récupérer le dump des infos de la trotinette

Code : Tout sélectionner

import time
import json

from m365py import m365py
from m365py import m365message


# callback for received messages from scooter
def handle_message(m365_peripheral, m365_message, value):
    print(json.dumps(value, indent=4))
    # Will print:
    # {
    #   "battery_percent": 84,
    #   "speed_kmh": 0.0,
    #   "speed_average_kmh": 0.0,
    #   "odometer_km": 155.819,
    #   "trip_distance_m": 0,
    #   "uptime_s": 159,
    #   "frame_temperature": 24.0
    # }

scooter_mac_address = 'XX:XX:XX:XX:XX:XX'
scooter = m365py.M365(scooter_mac_address, handle_message)
scooter.connect()

scooter.request(m365message.motor_info)
time.sleep(5)

scooter.disconnect()

- parser les infos récupérées (en PHP) dans un scénario Jeedom
- renseigner un virtuel avec ces infos récupéées

(Réflexion - très - rapide à chaud )

[benj29]

Ah j'avais ouvert un topic. Aussi. Je pense que l'on peut aussi traiter le flux json à la façon de ce que j'avais fait pour ma box aps.

Si un modo peut déplacer le message ici, merci

Envoyé de mon JSN-L21 en utilisant Tapatalk

[noodom]

Oui, je viens de voir ton fil à l'instant

[benj29]

J'essayerai de voir ce weekend ou dans la semaine pour adapter mon travail de la box APS (JSON/PHP/jeedom) sur la Xiaomi.

Comment as-tu fait pour l'ajouter sur BLEA ? Car j'ai scanné et je n'ai rien trouvé...

[noodom]

J'essaie de jeter un oeil ce soir pour une premiere approche sur ce qu'il est possible de faire (python/JSON/PHP/jeedom..)

Sinon, de mémoire,je n'ai rien fait de spécial pour l'inclure sur BLEA :
J'ai juste lancé un scan sur "Tous" et plein de devices inconnus sont apparus. J'ai dû retrouver la trottinette à l'aide de l'adresse MAC et j'ai supprimé les autres.

Tu as quoi comme clé bluetooth (J'ai une SENA avec une grande antenne) ? La trott' était suffisamment proche ?

[benj29]

J'ai une SENA à 1m et 5 PI dans la maison, ça va .
Mais non, pas reconnu. Faut que je regarde les logs, on verra plus tard .
Je vais déjà la charger pour mihome et l'utilisation de demain.
Recu ce jour .

[noodom]

Ah oui, c'est du tout frais en effet !

Tu as bien coché "Autoriser l'inclusion de devices inconnus" dans la configuration ?

Je me rappelle avoir mis les logs en debug pour analyser le scan et obtenir :
[DEBUG] : SCANNER------[(9, 'Complete Local Name', 'MIScooter5125')

EDIT : Je viens de refaire un scan BLEA sur mon jeedom de dev (simple clé USB bluetooth).
J'ai bien récupéré la trott dans la liste des devices inconnus avec pour nom "BLE MIScooter5125 AA:BB:CC:DD:EE:FF" (nom + @ MAC)

[benj29]

J'ai trouvé. Faut l'allumer. Mais le logo bluetooth est compliqué à avoir à on...

Envoyé de mon JSN-L21 en utilisant Tapatalk

[noodom]

Alors, après quelques tests hier, voilà un retour rapide sur l'utilisation du lien https://github.com/AntonHakansson/m365py/ :

- installation avec pip install.. en ssh : OK
- récupération de l'adresse MAC avec sudo python -m m365py en ssh : OK (des loupés de récupération parfois) mais pas indispensable si saisie à la main

- lancement du script complet d'exemple en ssh (https://github.com/AntonHakansson/m365p ... es/main.py) : OK pour la récupération des données de la trottinette (pas fait gaffe au lancement des actions on/off sur la lumière, lock et cruise)

- lancement du script de la page d'accueil du github pour la récupération de données par appel depuis un script Jeedom : KO. Ca me retourne None. Il faut que je vois si je gère mal l'utilisation de scripts python (et le langage aussi..) sous Jeedom

- lancement du script de Jeedom de la page d'accueil pour le lancement d'actions (on/off sur la lumière arrière, cruise control et lock) : OK

Conclusion :
- Il y a moyen de récupérer les infos, de faire des actions sur la trotinette mais il faut voir pour une intégration exploitable dans Jeedom (fiabilité de la gestion de la trottinette allumée ou pas (sinon gestion par action manuelle utilisateur), gestion de la connexion (réussie ou pas)
- A voir pour le problème de récupération des données par Jeedom mais ça devrait le faire vu que ça passe par script python en ssh

[benj29]

Côté BLEA, j'ai activé l'inclusion des devices inconnus (la trotin est 1.6.1).
Mais j'ai trouvé des devices mais aucun répondant au nom de MiScooter.
J'ai regardé dans l'application si j'ai moyen de trouver l'adresse MAC Bluetooth, pas trouvé.
Faut que je regarde si ça existe une application qui affiche les devices Bluetooth connectés au téléphone pour faciliter l'intégration.

Mais j'ai regardé côté BLEA, comment as-tu pour trouver la MAC ? J'ai tenté dans mes logs de filtrer avec MiScooter, nada....

[benj29]

Bon, déjà l'ID BT pour la pro, c'est MIScooter7275.
L'adresse MAC commence par ED:B0:.....

Ensuite, il m'en a remonté deux. A toi aussi ?
Elles ont la même mac adresse.



Je vais déjà voir pour gérer la première par présence.
Assez facile au final car même si je perds l'info présence quand elle est en veille, je sais si je viens d'arriver ou non.
Pratique pour ouvrir le portail/garage de manière automatique .

Ce serait intéressant de remonter plus d'info ensuite.
Je m'y pencherai comme j'ai fait pour la box APS. Mais c'est moins critique que le travail que j'avais fait. Surtout si l'auteur de BLEA bosse déjà dessus, je suis loin d'avoir les compétences pour l'intégrer dans un plugin. Moi ça restera du code et encore !

[noodom]

Salut,

Alors, non, je n'ai pas eu de doublon de device avec l'adresse MAC de la trott. Etonnant..
Le device que j'ai récupéré est bien sous la forme de ton premier device (BLE MIScooterXXXX avec XXXX différent pour chaque trott)
L'adresse MAC commence par E2:B7:....mais je ne pense pas que ça soit lié au modèle de trott.

Sinon, malgré un WE chargé, j'ai continué mes investigations hier soir et bonne nouvelle, le résultat est plutôt encourageant !
J'ai pu m'en sortir avec la récupération de données (pas simple de jouer avec le python..)

Du coup, j'ai pu continuer avec ton principe de gestion de ta box APS et faire une première version.

- j'ai un scénario qui se déclenche sur détection de présence de la trott. (par le plugin BLEA)
- Il commence par appeler un script qui me génère un fichier json des données récupérées
- Il fait ensuite un traitement php des données pour renseigner les champs d'un virtuel

- Dans mon virtuel, j'ai aussi ajouté les méthodes suivantes :
- allumer/éteindre la lumière arrière (toujours allumé ou pas quand tu roules)
- activer désactiver le mode cruise
- activer/désactiver le lock de la trott.

Je mettrai les sources ce soir.

[benj29]

Ah je prends. Tu m'enlèves une épine du pied. Faut que je remette les sources de mon code à jour car j'ai pas mal optimisé.

Envoyé de mon JSN-L21 en utilisant Tapatalk

[noodom]

Tuto [1/3] : Récupération des données de la trotinette M365 et M365 Pro pour intégration Jeedom,
basé sur la librairie m365py (https://github.com/AntonHakansson/m365py)

Avant tout, en ssh Jeedom, faire

Code : Tout sélectionner

pip install git+https://github.com/AntonHakansson/m365py.git#egg=m365py

On continue par créer un scénario :
- déclencheur : passage en mode présence de la trott dans le plugin BLEA (il faut inclure la reconnaissance auparavant dans ce plugin)

declencheur.png (6.71 Kio) Consulté 3552 fois

- Le principe de base est qu'il récupère les données de la trottinette (à partir d'un script Jeedom : voir ci-dessous) et qu'il les sauvegarde dans le fichier /var/www/html/montheme/m365/m365.json. Il faut donc créer l'arborescence /var/www/html/montheme/m365 sur son Jeedom

m365json.png (12.4 Kio) Consulté 3552 fois

- Ensuite, un traitement est effectué pour mettre à jour un virtuel regroupant les commandes de type infos de la trottinette (merci à @benj29 pour mon inspiration de son code d'intégration de sa box APS : viewtopic.php?f=157&t=47128&p=757588)

scenario.png (42.67 Kio) Consulté 3552 fois

- code de traitement des données dans le scénario : modifier l'adresse IP de Jeedom dans le code et le nom du virtuel pour les données de la trott. (ici : [Garage][m365 virtuel])

Code : Tout sélectionner

// traitement des données de la trottinette sous /var/www/html/montheme/m365/m365.json

$json = file_get_contents("http://192.168.0.130/montheme/m365/m365.json");

$arr = json_decode($json, true);

$battery_capacity = $arr['battery_capacity'];
$battery_current = $arr['battery_current'];
$battery_percent = $arr['battery_percent'];
$battery_temperature_1 = $arr['battery_temperature_1'];
$battery_temperature_2 = $arr['battery_temperature_2'];
$battery_voltage = $arr['battery_voltage'];
/*    "cell_voltages": [36.95, 36.98, 37.01, 36.95, 36.98, 37.03, 37.04, 37.06, 37.03, 36.97], */
$cell_voltages = $arr['cell_voltages'];
$distance_left_km = $arr['distance_left_km'];
$frame_temperature = $arr['frame_temperature'];
$is_cruise_on = ($arr['is_cruise_on']=='true')?1:0;
$is_lock_on = ($arr['is_lock_on']=='true')?1:0;
$is_tail_light_on = ($arr['is_tail_light_on']=='true')?1:0;
$kers_mode = ($arr['kers_mode']==0)?'faible':(($arr['kers_mode']==1)?'moyen':'fort');
$odometer_km = $arr['odometer_km'];
$pin = $arr['pin'];
$serial = $arr['serial'];
$speed_average_kmh = $arr['speed_average_kmh'];
$speed_kmh = $arr['speed_kmh'];
$trip_distance_m = $arr['trip_distance_m'];
$uptime_s = $arr['uptime_s'];
$version = $arr['version'];

// logs des données récupérées
$scenario->setLog('$battery_capacity : '.$battery_capacity);
$scenario->setLog('$battery_current : '.$battery_current);
$scenario->setLog('$battery_percent : '.$battery_percent);
$scenario->setLog('$battery_temperature_1 : '.$battery_temperature_1);
$scenario->setLog('$battery_temperature_2 : '.$battery_temperature_2);
$scenario->setLog('$battery_voltage : '.$battery_voltage);
$scenario->setLog('$cell_voltages : '.implode("/",$cell_voltages));
$scenario->setLog('$distance_left_km : '.$distance_left_km);
$scenario->setLog('$frame_temperature : '.$frame_temperature);
$scenario->setLog('$is_cruise_on : '.$is_cruise_on);
$scenario->setLog('$is_lock_on : '.$is_lock_on);
$scenario->setLog('$is_tail_light_on : '.$is_tail_light_on);
$scenario->setLog('$kers_mode : '.$kers_mode);
$scenario->setLog('$odometer_km : '.$odometer_km);
$scenario->setLog('$pin : '.$pin);
$scenario->setLog('$serial : '.$serial);
$scenario->setLog('$speed_average_kmh : '.$speed_average_kmh);
$scenario->setLog('$trip_distance_m : '.$trip_distance_m);
$scenario->setLog('$uptime_s : '.$uptime_s);
$scenario->setLog('$speed_average_kmh : '.$speed_average_kmh);
$scenario->setLog('$version : '.$version);

// on ajoute tous les éléments aux commandes infos du virtuel de la trottinette
$cmdString = "#[Garage][m365 virtuel][battery_capacity]#";
$cmd = cmd::byString($cmdString);
$cmd->event($battery_capacity.' Ah');

$cmdString = "#[Garage][m365 virtuel][battery_current]#";
$cmd = cmd::byString($cmdString);
$cmd->event($battery_current.' A');

$cmdString = "#[Garage][m365 virtuel][battery_percent]#";
$cmd = cmd::byString($cmdString);
$cmd->event($battery_percent.' %');

$cmdString = "#[Garage][m365 virtuel][battery_temperature_1]#";
$cmd = cmd::byString($cmdString);
$cmd->event($battery_temperature_1.' °');

$cmdString = "#[Garage][m365 virtuel][battery_temperature_2]#";
$cmd = cmd::byString($cmdString);
$cmd->event($battery_temperature_2.' °');

$cmdString = "#[Garage][m365 virtuel][battery_voltage]#";
$cmd = cmd::byString($cmdString);
$cmd->event($battery_voltage.' V');

$cmdString = "#[Garage][m365 virtuel][cell_voltages]#";
$cmd = cmd::byString($cmdString);
$cmd->event(implode("/",$cell_voltages));

$cmdString = "#[Garage][m365 virtuel][distance_left_km]#";
$cmd = cmd::byString($cmdString);
$cmd->event($distance_left_km.' kms');

$cmdString = "#[Garage][m365 virtuel][frame_temperature]#";
$cmd = cmd::byString($cmdString);
$cmd->event($frame_temperature.' °');

$cmdString = "#[Garage][m365 virtuel][is_cruise_on]#";
$cmd = cmd::byString($cmdString);
$cmd->event($is_cruise_on);

$cmdString = "#[Garage][m365 virtuel][is_lock_on]#";
$cmd = cmd::byString($cmdString);
$cmd->event($is_lock_on);

$cmdString = "#[Garage][m365 virtuel][is_tail_light_on]#";
$cmd = cmd::byString($cmdString);
$cmd->event($is_tail_light_on);

$cmdString = "#[Garage][m365 virtuel][kers_mode]#";
$cmd = cmd::byString($cmdString);
$cmd->event($kers_mode);

$cmdString = "#[Garage][m365 virtuel][odometer_km]#";
$cmd = cmd::byString($cmdString);
$cmd->event($odometer_km.' kms');

$cmdString = "#[Garage][m365 virtuel][pin]#";
$cmd = cmd::byString($cmdString);
$cmd->event($pin);

$cmdString = "#[Garage][m365 virtuel][serial]#";
$cmd = cmd::byString($cmdString);
$cmd->event($serial);

$cmdString = "#[Garage][m365 virtuel][speed_average_kmh]#";
$cmd = cmd::byString($cmdString);
$cmd->event($speed_average_kmh.' km/h');

$cmdString = "#[Garage][m365 virtuel][speed_kmh]#";
$cmd = cmd::byString($cmdString);
$cmd->event($speed_kmh.' km/h');

$cmdString = "#[Garage][m365 virtuel][trip_distance_m]#";
$cmd = cmd::byString($cmdString);
$cmd->event($trip_distance_m.' m');

$cmdString = "#[Garage][m365 virtuel][uptime_s]#";
$cmd = cmd::byString($cmdString);
$cmd->event($uptime_s.' s');

$cmdString = "#[Garage][m365 virtuel][version]#";
$cmd = cmd::byString($cmdString);
$cmd->event($version);

[noodom]

Tuto [2/3] Récupération des données de la trotinette M365 et M365 Pro pour intégration Jeedom,
basé sur la librairie m365py (https://github.com/AntonHakansson/m365py)

- Il faut ensuite créer un objet script (depuis le plugin script) et y créer une commande script pour appeler un script /var/www/html/core/php/../../plugins/script/core/ressources/jsonGeneration.sh

Code du script jsonGeneration.sh :

Code : Tout sélectionner

#!/bin/bash
sudo rm /var/www/html/montheme/m365/m365.json
sudo python /var/www/html/montheme/m365/jsonGeneration.py > /var/www/html/montheme/m365/m365.json

- Ensuite créer le fichier python /var/www/html/montheme/m365/jsonGeneration.py avec le code suivant (utiliser le plugin jeeXplorer) :

Code : Tout sélectionner

#!/usr/bin/python3

import time
import json

from m365py import m365py
from m365py import m365message

#import logging
#logging.getLogger('m365py').setLevel(logging.DEBUG)

# callback for received messages from scooter
def handle_message(m365_peripheral, m365_message, value):
    ret = 1

scooter_mac_address = 'AA:BB:CC:DD:EE:FF'
scooter = m365py.M365(scooter_mac_address, handle_message)
scooter.connect()

# Request all currently supported 'attributes'
scooter.request(m365message.battery_voltage)
scooter.request(m365message.battery_ampere)
scooter.request(m365message.battery_percentage)
scooter.request(m365message.battery_cell_voltages)
scooter.request(m365message.battery_info)

scooter.request(m365message.general_info)
scooter.request(m365message.motor_info)
scooter.request(m365message.trip_info)
scooter.request(m365message.trip_distance)
scooter.request(m365message.distance_left)
scooter.request(m365message.speed)
scooter.request(m365message.supplementary)
scooter.request(m365message.tail_light_status)
scooter.request(m365message.lock_status)
scooter.request(m365message.cruise_status)

# generation du fichier json de donnees
print(json.dumps(scooter.cached_state, indent=4, sort_keys=True))

time.sleep(5)

scooter.disconnect()

A valider si nécessaire : donner les droits suffisants au fichier et faire un chown www-data:www-data jsonGeneration.py (pareil pour le fichier m365.json et le répertoire /var/www/html/montheme/m365). Normalement, en créant le répertoire et les fichiers depuis jeeXplorer, les droits devraient être corrects.

- créer un virtuel pour les données de la trott

m365virtuelObjet.png (15.13 Kio) Consulté 3540 fois

Créer les commandes infos pour toutes les données : battery_capacity, battery_current, battery_percent, battery_temperature_1, battery_temperature_2, battery_voltage, cell_voltages, distance_left_km, frame_temperature, is_cruise_on, is_lock_on, is_tail_light_on, kers_mode, odometer_km, pin, serial, speed_average_kmh, speed_kmh, trip_distance_m, uptime_s, version

Les types seront à revoir : laissés en 'Autre' actuellement, sans doute à modifier pour les valeurs numériques.
Pour les champs is_tail_light_on, cruise_on et lock_on, je les ai déclaré en type 'Binaire' (avec pour valeur 0 ou 1 retournée par le script du scénario de mise à jour),

Pour l'instant, les données en mode true/false ne sont pas encore récupérées (en cours)

- Dans le virtuel, ajouter les commandes actions suivantes :

cmdActions.png (34.68 Kio) Consulté 3540 fois

[noodom]

Tuto [3/3] Récupération des données de la trotinette M365 et M365 Pro pour intégration Jeedom,
basé sur la librairie m365py (https://github.com/AntonHakansson/m365py)

Dans l'objet script créé précédemment, créer les commandes script pour les commandes actions appelées par le virtuel.
Ces commandes appellent le même script (m365actions.py) avec un paramètre différent pour définir l'action souhaitée.

Pour chaque commande du script, les appels seront donc les suivants :

scripts.png (66.32 Kio) Consulté 3451 fois

Le code du script m365actions.py est le suivant :

Code : Tout sélectionner

#!/usr/bin/python3

import time
import json
import sys

from m365py import m365py
from m365py import m365message

m365action=sys.argv[1]

# callback for received messages from scooter
def handle_message(m365_peripheral, m365_message, value):
    print (json.dumps(value, indent=4))

scooter_mac_address = 'AA:BB:CC:DD:EE:FF'
scooter = m365py.M365(scooter_mac_address, handle_message)
scooter.connect()

if m365action == 'lumiereOn':
	scooter.request(m365message.turn_on_tail_light)
elif m365action == 'lumiereOff':
	scooter.request(m365message.turn_off_tail_light)
elif m365action == 'cruiseOn':
	scooter.request(m365message.turn_on_cruise)
elif m365action == 'cruiseOff':
  	scooter.request(m365message.turn_off_cruise)
elif m365action == 'lockOn':
    scooter.request(m365message.turn_on_lock)
elif m365action == 'lockOff':
    scooter.request(m365message.turn_off_lock)
time.sleep(5)

scooter.disconnect()

Ce qui donne au final pour le visuel du virtuel de la trott' dans le dashboard :

m365virtuel.png (37.59 Kio) Consulté 3435 fois

[benj29]

Tu as 2 fois speed_average_kmh.

Je ne suis pas sûr de comprendre ton tuto ...
En gros, tu proposes de copier ton script .py en plusieurs scripts .py pour remonter un à un les éléments ?



Ce qui reviendrait à copier 15 fois ce script avec 14 commentaires de ligne # ?

En l’occurrence pour ma part, je ne prendrai que quelques infos ou actions : lock, km, batterie %, etc.

J'ai fait quelques modifications pour juste remonter les infos qui m'intéressent et pour faire un virtuel de gestion et quelques alertes. A voir après quelques essais.

[noodom]

Pour le doublon, tu parles de la liste dans mon tuto ? Je vais corriger. Je vérifierai dans le code si j'ai l'erreur aussi.

Sinon, un seul script suffit pour les commandes infos.

Les scripts qu'il faut dupliquer (en remplaçant chaque ligne), c'est seulement pour les commandes actions (allumer/éteindre lumière, ..). Il faut ensuite lier chaque script à une commande action du virtuel

En gros le scénario réclame les infos à la trot' (request qui s'enchaînent dans un script), les sauvegarde toutes dans un json pour ensuite mettre à jour ces données dans les infos du virtuel

[benj29]

Oui pour le doublon, simple erreur de copier coller. OK, je comprends mieux.
Bon je dois regarder quand j'ai le temps mais visiblement il n'a pas trouvé la trottinette à mon arrivée...
Mais mon fils lui m'a trouvé

Envoyé de mon JSN-L21 en utilisant Tapatalk