Un système de modules créés par l'utilisateur

Bonjour,

Je souhaiterais créer une app Web permettant à l'utilisateur d'y greffer ses modules. C'est la partie "Contrôle" de cela :

L'objectif est de faire de la modulation de dose dans un verger : distribuer telle quantité de produit de traitement selon la densité de fleurs de la zone considérée. Concrètement, on photographie un verger (A), associe une image à chaque zone (B) et calcule la densité de floraison de chacune (C). Puis on génère une carte du genre cela.

Sur une Raspberry, il y a une interface de contrôle - une app Web - : elle affiche la carte et permet de communiquer avec des modules. Par exemple, un de ces derniers est celui de localisation : à partir de capteurs banchés à la RPi, il est en mesure de donner la position du tracteur dans le verger quand le module de contrôle le lui demande.

Concrètement, un module sur la RPi, c'est :

• Des entrées via les GPIO
• Un programme d'analyse des données reçues des entrées
• Une interface graphique propre au module (pour faire des réglages, afficher les valeurs reçues des entrées…)
• Des sorties via les GPIO

Je souhaiterais pouvoir donner la possibilité à l'utilisateur d'ajouter d'autres modules aisément. Par exemple, il pourrait vouloir brancher une sonde de température sur la carte, récupérer la température courante, et l'afficher. Mais je voudrais que ces modules puissent être facultatifs.

Du coup, est-il possible de mettre tout ça ensemble sans demander à l'utilisateur de modifier le code pour y intégrer ses modules ?

Un truc tout simple consisterait à ouvrir chaque module - i.e. app Web - dans un onglet du navigateur et chacun serait indépendant. Seulement, je souhaiterais qu'ils puissent communiquer. Par exemple, le module de localisation donnerait la position au module de contrôle qui la transmettrait à celui de gestion des quantités de produit de traitement qui pourrait, imaginons, consulter le module de température, s'il existe, pour affiner la dose - pour l'exemple, vu qu'elle ne dépend a priori pas de la température.

Le plus complexe, ce n'est pas l'agencement des modules mais le fait qu'ils proviennent de l'utilisateur. Si je les programme moi-même, je peux aisément les faire interagir, mais comment s'y prendre pour donner à l'utilisateur la possibilité d'utiliser ses propres modules et de les faire interagir avec les autres sans trop de difficulté ?

Côté serveur, j'utiliserai probablement Flask.

Merci ! =)

Salut,

Ton besoin ressemble beaucoup à l'ouverture aux plugins de différents CMS. Pour ce faire, il faudrait que ton app aie des points d'entrée, qui permettrait à ce module de modifier/compléter ces fonctionnalités. Ton app regarderait systématiquement la présence de module connecté sur chaque entrée, et s'il y a un module, appellerait à certains moments définis des méthodes/fonctions au nom prédéfinis.

Par exemple, au démarrage, tu vérifies la liste des entrées connectées/non connectées, et tu enregistre dans un tableau la liste des entrées utilisées. Puis, a des moments clés, tu va lancer des fonctions au nom que tu auras définis.

Concrètement, si on parle d'une sonde, pour ton interface de synthèse, à la fin de ta page tu peux faire un:

1

Si présence sonde, lancer la fonction display();

Et si un autre module peut utiliser la valeur de la sonde, si elle est connectée, c'est à toi de prévoir (ou au concepteur du module) cette utilisation, avec quelque chose du type:

1
2

Si présence sonde, température = getTemp();
Sinon, température = 20;

Et dans ta doc à destination des créateurs de module, tu explique que les modules doivent avoir une fonction display() qui affichera les infos sur la page de synthèse, et que les sondes doivent renvoyer leur température avec la fonction getTemp().

J'ai l'impression de souvent ressortir cet article mais ce que tu cherches à faire, il me semble, passe par l'implémentation du publish / subscribe pattern.

Tu as une liste de "topics" comme la température (note : c'est l'exemple de Wikipedia en Français d'ailleurs) auxquels tes modules peuvent souscrire.

J'espère que cette doc pourra t'aiguiller dans tes recherches (difficile de rentrer plus dans les détails d'implémentation, je le reconnais), sinon n'hésite pas à revenir nous faire signe.

Bon courage.

Merci. J'aurais quelques questions :

• Je pensais centraliser : chaque module envoie leurs signaux à un même module - le contrôleur -, qui les transmet à tous les autres. Est-ce une bonne méthode ?
• Faut-il que les modules demandent l'information ou qu'ils l'attendent ? Par exemple, est-ce à mon module "Température" de décider quand les autres reçoivent les données ?
• De quelle manière puis-je connecter des modules sans toucher au code ? Pour l'utilisateur, il faudrait que ça se résume à une liste de modules qu'on coche pour les activer ou non.
• Comment relier l'interface graphique au module ? Faut-il, côté client, que j'envoie un signal au serveur quand la valeur d'un champ est changée et que le serveur se charge de transmettre le signal aux modules Python ?
• Je pensais utiliser PyPubSub et les websockets pour les communications : module (serveur - Python) <-> contrôleur (serveur - Python) <-> GUI (client - HTML/JS). Faut-il que j'implémente un PubSub pattern côté client également faire parvenir les entrées utilisateur aux modules ?

L'objectif reste, me semble-t-il, de permettre de rajouter des modules sans modifier le code du programme - en gros, comme on fait avec les navigateurs -, un module étant :

• une partie Python reliée à la Raspberry
• une interface graphique pour effectuer des réglages, lire les valeurs…

Merci ! =)