Visualiser une méthode pour la modifier

Depuis l'article d'hier, où l'on a vu comment enregistrer une méthode simple pour l'envoyer à notre maison, ou à tout système Smag0, je l'ai un petit peu remaniée.
 Pour quelle soit encore plus simple, j'ai utilisé le format .xls propre à Excel... Qui ne connait pas Excel... (Possible aussi avec LibreOffice, Openoffice...).

J'ai donc repris la méthode que l'on a confectionné hier, et j'en ai fait un fichier .xls de trois colonne, la première représentant un sujet, la deuxième, une propriété, et la troisième l'objet au sens de RDF (voir l'article précédent pour ceux qui auraient loupé la séance d'hier) avec nos déclarations :

CuireDesPâtes	rdf:type	Methode
FaireBouillirEau	rdf:type	Etape
AjouterSel	rdf:type	Etape
VerserPâtes	rdf:type	Etape
Remuer	rdf:type	Etape
Attendre10Min	rdf:type	Etape
EgoutterPâtes	rdf:type	Etape
CuireDesPâtes	dc:hasPart	FaireBouillirEau
CuireDesPâtes	dc:hasPart	AjouterSel
CuireDesPâtes	dc:hasPart	VerserPâtes
CuireDesPâtes	dc:hasPart	Remuer
CuireDesPâtes	dc:hasPart	Attendre10Min
CuireDesPâtes	dc:hasPart	EgoutterPâtes
CuireDesPâtes	rdf:first	FaireBouillirEau
FaireBouillirEau	xhv:next	AjouterSel
AjouterSel	xhv:next	VerserPâtes
VerserPâtes	xhv:next	Remuer
VerserPâtes	xhv:next	Attendre10Min
Attendre10Min	xhv:next	EgoutterPâtes
EgoutterPâtes	xhv:next	MethodeServirPâtes
FaireBouillirEau	dc:hasPart	SortirCasserole
FaireBouillirEau	dc:hasPart	RemplirEau
FaireBouillirEau	dc:hasPart	PoserSurGaziniere
FaireBouillirEau	dc:hasPart	AllumerLeFeu
SortirCasserole	dc:hasPart	AllerDevantPlacardBasGauche
SortirCasserole	dc:hasPart	OuvrirPortePlacardBasGauche
SortirCasserole	dc:hasPart	AttraperCasserole
SortirCasserole	dc:hasPart	Reculer
SortirCasserole	dc:hasPart	FermerPlacardBasGauche
SortirCasserole	dc:hasPart	SeDeplacerVersEvier
AllerDevantPlacardBasGauche	xhv:next	OuvrirPortePlacardBasGauche
OuvrirPortePlacardBasGauche	xhv:next	AttraperCasserole
AttraperCasserole	xhv:next	Reculer
Reculer	xhv:next	FermerPlacardBasGauche
FermerPlacardBasGauche	xhv:next	SeDeplacerVersEvier
SeDeplacerVersEvier	xhv:next	RemplirEau
MethodeServirPâtes	rdf:type	Methode
CuireDesPâtes	xhv:next	MethodeServirPâtes
PoserSurGaziniere	xhv:next	AllumerLeFeu
RemplirEau	dc:hasPart	PlacerCasseroleSousRobinet
RemplirEau	dc:hasPart	AllumerRobinet
RemplirEau	dc:hasPart	RemplirCasseroleAuTroisQuarts
RemplirEau	dc:hasPart	FermerRobinet
FermerRobinet	xhv:next	PoserSurGaziniere
PlacerCasseroleSousRobinet	xhv:next	AllumerRobinet
AllumerRobinet	xhv:next	RemplirCasseroleAuTroisQuarts
RemplirCasseroleAuTroisQuarts	xhv:next	FermerRobinet
FermerRobinet	xhv:next	PoserSurGaziniere

 Bon, ok, j'ai rajouté quelques petits trucs depuis hier.

Mais ça commence à devenir intéressant...

ça nous donne ça  :

En utilisant Processing et la librairie Traer.physics un peu remaniée ( pour pouvoir ensuite l'intégrer dans une page web, j'ai utilisé cette version ci-> http://svbreakaway.info/tp-downloads.php#tpjs )

Pour télécharger le code Processing c'est ici :
https://drive.google.com/file/d/0B0zEK4yLB5C6MEhnVkdlZC1ZQ0U/view?usp=sharing

reste à modifier la couleur des liens, la longueur en fonctions de la propriété, indique clairement le nom des propriétés, pour facilement trouver la première sous-étape de chaque étape.

A voir, mais on peu peut-être modifier  :

VerserPâtes	xhv:next	Remuer
VerserPâtes	xhv:next	Attendre10Min

en une nouvelle étape de type Boucle ou Alternance (voir si ça existe, ou si on doit les créer) , ou je ne sais quoi, qui aurait une durée de 10 Minutes, serait composé de deux sous étapes : Remuer et Attendre, qui aurait elles aussi aurait une propriété durée...( remuer 10 secondes, attendre 1minute)

Prochaine étape : intégrer une méthode sur la page d'un projet .


A voir aussi avec tree.js http://mrdoob.github.io/three.js/examples/#webgl_nearestneighbour, pour visualiser les informations, http://workshop.chromeexperiments.com/ pour le GUI, ou https://github.com/blprnt/Infinite-Weft.html et http://sketchpad.cc/mwxwmUdIVC?exampleType=topic&exampleName= pour faire des tests

Ajouter une méthode simple à un projet Smag0

Nous avons tenté d'expliquer dans l'article http://smag0.blogspot.fr/2015/06/comment-creer-une-methode-pour-smag0-la.html comment créer une méthode, en nous attaquant à la méthode Diamond. Mais cette méthode est complexe, et longue à mettre en place, on verra ça plus tard.

N'allons pas trop vite en besogne, procédons par ordre. Pour l'instant nous avons la possibilité d'enregistrer les projets ou les instructions que l'on veut envoyer à notre maison, via l'appli Coolitude4, ou via la page des projets, nous avons la possibilité d'ajouter des commentaires sur les projets proposés, et d'extraire de ces projets les termes importants, de les enregistrer au format RDF. Si RDF ne vous dit rien, jetez un petit coup d'oeil sur https://fr.wikipedia.org/wiki/Resource_Description_Framework pour que ce soit plus clair.
(NB : les liens mentionnés sont susceptibles de changer, merci de me le signaler, si vous n'y trouvez plus rien).

Une fois que l'on a notre projet, ou notre requête envers notre maison (voir ASACURQRSC ), 
le système doit posséder des méthodes pour analyser, interpréter, exécuter les instructions.
Partons donc d'un truc tout simple, par exemple... il est 20h36, c'est l'heure de manger, je voudrais manger des pâtes, c'est mon projet, ça devient une requête envers le système qui serait peut-être un jour capable de me faire cuire des pâtes sans me répondre " va te faire cuire un œuf".
Pour que le système puisse y parvenir, il va avoir besoin d'une méthode, comme nous quand on va sur http://www.marmiton.org ... mais en attendant qu'il aille y chercher des recettes complexes, tentons d'établir une méthode simple pour transmettre au système la méthode pour cuire des pâtes.

Primo : c'est quoi la méthode pour faire cuire des pâtes ??
source  : Farfalle - Barilla
 (je dois être le seul mec de tout l'internet à prendre mon code source sur les paquets de pâtes Barilla ;-%)

Modalité de cuisson pour 100g de pâtes :
1 litre d'eau
7g de sel

Faire bouillir l'eau et ajouter le sel.
Verser les pâtes et remuer de temps en temps.
Temps de cuisson 10 min.
Egoutter les pâtes.

En décomposant par étape, en gros, ça ferait :
1. Faire bouillir l'eau
2. Ajouter le sel
3. Verser les pâtes
4. Remuer de temps en temps (pendant 10 minutes )
5 Egoutter les pâtes

Le but étant de créer une méthode exploitable, enregistrable, partageable, modifiable, n'ayant pas trouvé mieux que RDF pour décrire, on va tenter de se le faire avec des triplets, comme ça  :
(voir aussi http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/)

ici, on va utiliser la propriété rdf:type pour dire que CuireDesPâtes est_une Methode, ou que FairteBouillirEau est_une Etape...

{CuireDesPâtes  rdf:type  Methode}
{FaireBouillirEau rdf:type Etape}
{AjouterSel rdf:type Etape}
{VerserPâtes rdf:type Etape}
{Remuer rdf:type Etape}
/* avoir comment faire le de temps en temps, et le attendre 10 mins... faire les deux actions en parrallèle ??? temporiser ??*/
{EgoutterPâtes rdf:type Etape }

Voilà nos 5 étapes.

Ensuite, pour dire que la méthode CuireDesPâtes est composée de plusieurs étapes nommées FaireBouillirEau, AjouterSel..., on utilisera dc:hasPart, ce qui donnera

{CuireDesPâtes dc:hasPart FaireBouillirEau }
{CuireDesPâtes dc:hasPart AjouterSel
{CuireDesPâtes dc:hasPart VerserPâtes
{CuireDesPâtes dc:hasPart Remuer
{CuireDesPâtes dc:hasPart Attendre10Min } //encore à définir
{CuireDesPâtes dc:hasPart EgoutterPâtes }


on pourra compléter de la manière suivante en utilisant rdf:first pour dire que FaireBouillirEau est la première étape de la méthode CuireDesPâtes.

{CuireDesPâtes rdf:first FaireBouillirEau }

A ce stade, on serait tenter d'utiliser les Collections RDF : https://code.google.com/p/collections-ontology/wiki/RDFContainersAndCollections
mais ceci ne conviendrait pas, on créerait une Sequence avec rdf:Seq, mais on serait obligé de numéroter les étapes, alors que nous voulons quelque chose de souple. Ainsi, si j'ai envie de me créer ma propre méthode CuireDesPâtes2, et que moi, quand je fais des pâtes, j'ai l'habitude de mettre un couvercle, pour que la température de l'eau augmente plus vite ( ce qui n'est pas recommandé par Barilla, cela dit en passant... que ce soit clair entre vous et moi !). Bon admettons que l'on veuille rajouter une étape comme MettreCouvercle... Si on numérote les étapes avec les  propriétés préconisées rdf:_1, rdf:_2..., on sera embêté lors de l'insertion, il faudra renommer toute la suite, de même si on veut supprimer une étape. On va plutôt utiliser une propriété qui nous dira le "suivant" de FaireBouillirEau est AjouterSel.  Cette propriété "suivant" ou "next" (en anglais) ne semble pas avoir été prévu dans les vocabulaires rdf ou rdfs... Comment faire ...??? là se pose la question de tout développeur normalement constitué, qui s'est un peu penché sur RDF, et la notion de réutilisation des vocabulaires. Dois-je créer ma propre propriété avec mon propre prefix, un truc du style "smag:next"???

Que nenni, car c'est là qu'intervient notre ami Lovokfnorg ou plutôt http://lov.okfn.org/... Qui c'est celui-là ? un moteur de recherche de vocabulaires RDF... et en lui demandant s'il connait quelque chose qui correspondrait à notre "next" tant désiré, il nous répond :

• xhv:next(xhv)0.780
  

  7 occurrences in 5 LOD datasets

  http://www.w3.org/1999/xhtml/vocab#next

  http://www.w3.org/ns/rdfa#term next

  rdfs:comment next refers to the next resource (after the

  localName next

  http://www.w3.org/ns/rdfa#uri http://www.w3.org/1999/xhtml/vocab#next
• dqm:next(dqm)0.532
  

  n/a (use in LOD)

  http://purl.org/dqm-vocabulary/v1/dqm#next

  rdfs:comment Links an instances to the next instance in an ordinal scale. @en

  localName next
• olo:next(olo)0.532
  

  n/a (use in LOD)

  http://purl.org/ontology/olo/core#next

  rdfs:label has next @en

  rdfs:comment Associates the next slot in an ordered list. @en

  localName next

on a 71 réponses (peut-être plus quand vous lirez cet article), et déjà, les trois premières nous conviennent... Quelle utilité d'en créer une 72ème qui ne sera utilisée par personne d'autre que par moi. Prenons la plus populaire : xhv:next

On peut donc écrire (non, je ne met pas le couvercle, vous le mettrez si vous voulez... en plus , y'a des risques de débordement...) les triplets suivants :

{ FaireBouillirEau xhv:next AjouterSel }
{AjouterSel xhv:next VerserPâtes }
{VerserPâtes xhv:next RemuerDeTempsEnTemps }
{VerserPâtes xhv:next Attendre10Min }
{Attendre10Min xhv:next EgoutterPâtes }



On a maintenant une structure cohérente sans trop mettre les pieds dans le plat... de pâtes. Bon ok, c'est nul... Avec VerserPâtes qui possède deux xhv:next : RemuerDetempsEnTemps et Attendre10Min.

On a maintenant tout ce qu'il faut pour compléter notre méthode CuireDesPâtes. on peut par exemple décomposer les étapes... avec les propriétés dc:hasPart, rdf:first et xhv:next
L'étape FaireBouillirEau pourrait être composée d'autres étapes, comme SortirCasserole, RemplirEau, PoserSurGaziniere, AllumerLeFeu... et oui, Johnny...
SortirCasserole se décomposerait en AllerDevantPlacardBasGauche, OuvrirPortePlacardBasGauche, AttrapperCasserole, Reculer, FermerPlacardBasGauche, SeDeplacerVersEvier...


On peut ainsi stocker n'importe quelle méthode sur notre serveur RDF (avec Fuseki), ou sous forme de fichier rdf/owl téléchargeable.
ps : j'ai zappé pas mal de principes RDF, préfixe, etc... pour que ce soit plus clair à un non initié, mais l'intéressé pourra se rendre là : https://fr.wikipedia.org/wiki/Resource_Description_Framework ou là http://www.w3.org/TR/rdf-syntax-grammar/
 ou là en français : https://www.google.fr/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=rdf%20francais 

Reste à créer une interface conviviale pour enregistrer, éditer, visualiser les méthodes...

Contrôler une camera Pan-Tilt sur serveur Pcduino via Wifi

Bon, ça fait un bout de temps que j'avais laissé de côté le pcduinoBot, mais j'avais fait quelques test satisfaisant.
Il est maintenant temps de reprendre ce code, pour en faire une interface conviviale.

J'étais parti sur un serveur Flask (Python) pour pouvoir accéder aux commandes du pcduinoBot, basé sur le code https://github.com/pcduino/python-pcduino.

... heu pas le temps pour l'instant, je reviendrais plus tard

Comment créer une méthode pour Smag0, la méthode Diamond, au format RDF

On peut maintenant enregistrer un nouveau projet ou une information à transmettre à sa maison, grâce à l'appli Coolitude4, ou bien directement sur le site http://smag-smag0.rhcloud.com/visu.jsp.

Ensuite, pour nous aider à réaliser ce projet, ou pour aider le système à analyser l'information qu'on lui a envoyer, nous allons de voir utiliser une ou plusieurs méthode. Cet article décrit comment créer une nouvelle méthode et comment l'intégrer au système Smag0. On pourra de la même manière créer d'autres méthodes, des procédures métiers, des recettes de cuisine, des manières de ranger une chambre. Ces méthodes sont partageables et utilisables par plusieurs systèmes, elles devront également être personnalisables, selon l'envie, le contexte de chacun.

J'avais dans un premier temps, fait un premier test pour modéliser la méthode Diamond en me basant sur ce document : DIAMOND : Une approche pour la conception de systèmes multi-agents embarqués par Jean-Paul Jamont, et ça nous donnait ceci : http://smag0.rww.io/diamond.owl.

On pourra aussi se pencher sur la méthode ASPECS à laquelle est étroitement liée Janus.

J'ai depuis approfondi mes connaissances en RDF, et il apparaît opportun, d'utiliser au maximum des vocabulaires déjà existants, pour renforcer la compatibilité et la portabilité d'un méthode.

pour un rappel (ou une découverte) sur RDF et ses triplets, un petit coup d'oeil sur Wikipedia.

Une méthode est tout d'abord une séquence ordonnée d'instructions, ce qui se traduit en RDF par le triplet suivant : 

{ MethodeDiamond        rdf:type     rdf:Seq }

avec rdf:type : http://www.w3.org/TR/rdf-schema/#ch_type : 

rdf:type est une instance de rdf:Property qui est utilisé pour indiquer qu'une ressource est une instance d'une classe.Un triplet de la forme: R rdf:type Cstipule que C est une instance de rdfs:Class et R est une instance de C.Le rdfs:domain de rdf:type est rdfs:Resource. Les rdfs:range de rdf:type est rdfs:Class.

et rdf:Seq : http://www.w3.org/TR/rdf-schema/#ch_seq :

Le rdf:Seq est la classe de «séquence» conteneurs RDF. Il est une sous-classe de rdfs:Container. Bien que formellement il est pas différent d'un rdf:Bag ou un rdf:Alt. rdf:Seq est utilisée conventionnellement pour indiquer à un lecteur humain que l'ordre numérique des propriétés d'appartenance de conteneur du conteneur est destiné à être significatif.

La méthode Diamond (enfin, comme je l'ai comprise ;-)) se décompose en 4 étapes majeures : 

1. A. Définition des besoins
2. B. Analyse du système Multi-Agents
3. C. Conception Générique
4. D. Implantation

ce qui se traduira par les triplets suivants

{ MethodeDiamond rdf:_1 DefinitionDesBesoins }

{ MethodeDiamond   rdf:_2 AnalyseSMA }

{ MethodeDiamond   rdf:_3 ConceptionGenerique }

{ MethodeDiamond   rdf:_4 Implantation }

Chacun de ces étapes majeures étant elle même une séquence  composée d'autres étapes, on continuera donc en décrivant l'étape DefinitionDesBesoins par les triplets suivants : 

{ DefinitionDesBesoins rdf:type  rdf:Seq  }

{ DefinitionDesBesoins rdf:_1 ApprochePreliminaire }

{ DefinitionDesBesoins rdf:_2 EtudeActeurs }

{ DefinitionDesBesoins rdf:_3 EtudeCasUtilisation }

{ DefinitionDesBesoins rdf:_4 EtudeBesoinsService }

{ DefinitionDesBesoins rdf:_5 EtudeModeMarcheArret }

et ainsi de suite,
pour plus d'infos sur comment construire une ontologie :
http://python.espe-bretagne.fr/master-hst-ue9-2/wp-content/uploads/2013/03/Tutoriel-Pizza-gloria-1.pdf
http://protegewiki.stanford.edu/wiki/Protege4Pizzas10Minutes
http://protegewiki.stanford.edu/wiki/Protege4UserDocs

Bien , maintenant, passons à la pratique.

Commencez par télécharger et exécuter Protégé2000,
ensuite nommez votre ontologie comme décrit dans les tutoriels juste au dessus (si vous bloquez à ce niveau, demandez de l'aide dans un des groupes de discussion du blog, ou en commentaire de cet article), et importez le vocabulaire rdf : http://www.w3.org/1999/02/22-rdf-syntax-ns#

dans votre ontologie.
Cela nous donnera accès aux classes rdf:Seq et aux propriétés rdf:type...
Ensuite, pour avoir accès à la numérotation, on va aussi importer le vocabulaire rdfs : http://www.w3.org/1999/02/22-rdf-syntax-ns#

dans objectPropertyHierarchie, ajouter des sous-propriétés à la propriété "member" telles que celles-ci : 
http://www.w3.org/1999/02/22-rdf-syntax-ns#_1
http://www.w3.org/1999/02/22-rdf-syntax-ns#_2
http://www.w3.org/1999/02/22-rdf-syntax-ns#_3
...

article), et importez le vocabulaire r
Creez une classe Methode sous la classe Thing, et créez une instance "MaMethode" de type "Methode".

•  ajoutez le type "Seq" à "MaMethode". --> ceci nous donnera le triplet { MethodeDiamond        rdf:type     rdf:Seq }
• ensuite utilisez les propriétés _1, _2 que vous avez créé sous la propéiété member, et créez les instances  DefinitionDesBesoins, AnalyseSMA  ConceptionGenerique  Implantation ,
  ce qui nous donnera les triplets :
  
  { MethodeDiamond rdf:_1 DefinitionDesBesoins }
  { MethodeDiamond   rdf:_2 AnalyseSMA }
  { MethodeDiamond   rdf:_3 ConceptionGenerique }
  { MethodeDiamond   rdf:_4 Implantation }

On peut ensuite ajouter le type Seq à ces quatres instances et continuer, en décrivant les sous-étapes de ces étapes, et ainsi de suite...

Le but étant d'avoir une structure récursive, identique pour toutes les méthodes, afin de pouvoir être utilisé de manière transparente par différentes applications.

On a décrit ici comment construire l'ontologie. on pourra ensuite la stocker sur http://rww.io/ (attention, la survie de ce site n'est pas garantie), ou sur un truc comme https://github.com/scenaristeur/smagserver/tree/master/src/main/webapp/ontologies, pour avoir une possibilité d'évolution, de versionning sur l'ontologie.

Pour l'instant, une première version là : http://smag-smag0.rhcloud.com/ontologies/diamondMethode.owl

reste à ajouter un formulaire sur Smag0 pour intégrer de nouvelles ontologies.