Affichage des articles dont le libellé est projet. Afficher tous les articles
Affichage des articles dont le libellé est projet. Afficher tous les articles

14/09/2019

La Barrière LEGO avec telecommande - Arduino

Cet article fait suite à l'article La Barrière LEGO

Car c'est bien beau d'avoir une barrière LEGO qui se lève à l'approche d'un véhicule, seulement le problème, c'est une fois que l'on est passé, comment on fait pour revenir, car il n'y a pas de capteur de l'autre côté de la barrière...

La solution est d'utiliser une télécommande, sur laquelle nous utiliserons deux boutons... un pour lever la barrière et l'autre pour la baisser !

<video>

Prenez maintenant la télécommande et son capteur fournis dans le kit (voir  l'article La Barrière LEGO pour vous procurer le kit )


Sur la plaque du capteur infrarouge, repérez les broches S et -

PINDescriptionCouleur du câbleConnexion vers la carte ARDUINO
SSortie des donnéesmarronD11
3.3 - 5Vrouge VCC  / 5V
-0Vnoir GND

--> Utilisez les câbles fournis avec la télécommande et reliez
la pin S du capteur à la pin D11 de la carte Arduino
la pin du milieu du capteur à la pin 5V / VCC de la carte Arduino
la pin - du capteur

<troisphotos branchements>



Installez la librairie IRremote et ouvrez l'exemple IRrecvDemo
<trois photos install>

Nous n'allons pas nous servir du code hexadécimal de la touche, mais son code décimal. Pour ce faire, ajoutez la ligne
 Serial.println(results.value);

comme indiqué dans le code ci-dessous :

#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
}
void loop() {
  if (irrecv.decode(&results)) {
    Serial.println(results.value, HEX);
Serial.println(results.value);
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

Enregistrez ce code sous le nom de "Test_Telecommande" et téléverser-le sur la carte.


Ouvrez le moniteur série (dans le menu Outils) et appuyez alternativement sur les touches "Fleche Haut" et "Fleche Bas" de la télécommande.
Attention, si vous appuyez trop longtemps sur une touche, il peut arriver que les codes parasites "FFFFFFFF" et "4294967295", mais nous allons les gérer


<photo codes>

A chaque appui de touche, vous devriez voir apparaître un code correspondant à la touche appuyée . Moi j'ai pour :

Flèche HAUTFlèche BAS
code hexadécimalFF18E7FF4AB5
code décimal1671805516730805

Notez les codes que vous affiche le moniteur, ils peuvent être différents des miens !


Modifiez maintenant le code de la manière suivante pour détecter l'appui sur les deux flèches "HAUT" et "BAS".





#include <IRremote.h>
int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
}
void loop() {
  if (irrecv.decode(&results)) {
    // Serial.println(results.value, HEX);
    // Serial.println(results.value);
    if (results.value == 16718055) {
      Serial.println("HAUT");
    } else if  (results.value == 16730805) {
      Serial.println("BAS");
    } else {
      Serial.println(results.value);
    }
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

Enregistrez votre programme (que l'on appelle également Sketch chez Arduino), et téléversez-le sur la carte. Ouvrez-le moniteur série et appuyez successivement sur les touches "HAUT" et "BAS". Ces deux mots devraient maintenant s'afficher dans le moniteur :

<photo moniteur haut bas>

On va maintenant utiliser deux fonctions leve_barriere() et baisse_barriere() dans lesquelles ont ajoutera le code contrôlant le servomoteur...

Modifiez maintenant le code comme suit :

00);


#include <IRremote.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
}

void loop() {
  if (irrecv.decode(&results)) {
    // Serial.println(results.value, HEX);
    // Serial.println(results.value);
    if (results.value == 16718055) {
      leve_barriere();
    } else if  (results.value == 16730805) {
      baisse_barriere();
    } else {
      Serial.println(results.value);
    }
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

void leve_barriere(){
  Serial.println("HAUT dans la fonction");
}

void baisse_barriere(){
  Serial.println("BAS dans la fonction");
}


<photo leve barriere fonction>


Bien bien bien, pas mal jusque là... Il ne nous reste plus qu'à brancher le servomoteur comme dans l'article précédent  sur la PIN D9 et à ajouter le code qui gère ce moteur :

Comme on n'a pas utilisé les lignes "bleus et rouges" pour le 5V et le GRND, on va juxtaposer les câbles d'alimentation du moteur à ceux du capteur infra rouge .

<photos branchement moteur>

Un petit peu de copier/coller  depuis le code produit dans l'article précédent, et votre code pourrait ressembler à ceci :




#include <IRremote.h>
#include <Servo.h>

int RECV_PIN = 11;

IRrecv irrecv(RECV_PIN);

decode_results results;

/* Creation d'un objet Servo pour contrôler le servomoteur */
Servo mon_servo;

void setup()
{
  Serial.begin(9600);
  // In case the interrupt driver crashes on setup, give a clue
  // to the user what's going on.
  Serial.println("Enabling IRin");
  irrecv.enableIRIn(); // Start the receiver
  Serial.println("Enabled IRin");
  mon_servo.attach(9);
  mon_servo.write(180);
}

void loop() {
  if (irrecv.decode(&results)) {
    // Serial.println(results.value, HEX);
    // Serial.println(results.value);
    if (results.value == 16718055) {
      leve_barriere();
    } else if  (results.value == 16730805) {
      baisse_barriere();
    } else {
      Serial.println(results.value);
    }
    irrecv.resume(); // Receive the next value
  }
  delay(100);
}

void leve_barriere() {
  Serial.println("HAUT dans la fonction");
  mon_servo.write(90);
}

void baisse_barriere() {
  Serial.println("BAS dans la fonction");
  mon_servo.write(180);
}





ET voilà, notre Barrière LEGO télécommandée  !!!!!

<video >

Ajouter des leds pour indiquer si l'on peut avancer ou pas ???

Inspirez-vous de ce code  : un mix des exemples  Blink  et Fade  présents dans Fichier / Exmples / 01.Basic ou sur le site Arduino  --> vous aurez aussi des indications sur la manière de brancher vos leds si vous avez des doutes


Connectez vos led sur les pin 5 et 7 de l'Arduino
Sans oublier de les protéger par des resistances de 220 ohms ! 


int led_rouge = 5;
int led_verte = 7; 
void setup() {
  // initialize digital pin as an output.
  pinMode(led_rouge, OUTPUT);
  pinMode(led_vertee, OUTPUT);
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(led_rouge, HIGH);   
  digitalWrite(led_verte, LOW);  
  delay(1000);                      
  digitalWrite(led_rouge, LOW);   
  digitalWrite(led_verte, HIGH); 
  delay(1000);                      
}












10/06/2018

La Barrière LEGO - Arduino

Objets connectés, iot, Arduino, par où commencer ?


"La barrière LEGO, un bon projet pour débuter avec Arduino".


" ça serait bien, une barrière pour ma maison LEGO !
- Une barrière pour ta maison de LEGO, ok, qu'est-ce qu'il nous faut ? Un moteur pour actionner la barrière, et un moyen de la déclencher. Pour le moteur, on va utiliser un SG90, fourni avec la plupart des kits Arduino, et pour activer ce moteur ?? J'ai une Funduino Mega2560 qui traîne, on va voir ce qu'on peut faire avec, mais note que n'importe quelle carte Arduino, ou compatible doit faire l'affaire..."



ES-TU PRÊT A RELEVER LE DEFI DE CREER UNE BARRIERE LEGO EN SEULEMENT 20 LIGNES DE CODE ???

- niveau débutant,
- matériel : KIT "Barrière LEGO Arduino" comprenant :

  • une carte arduino
  • une breadboard
  • un capteur ultrason
  • un servomoteur
  • une télécommande infrarouge et son capteur
  • quelques leds de couleur et les resistances qui les protègent
  • des câbles pour effectuer les connexions...
C'est tout ce qu'il faut pour construire les deux versions de la "Barrière LEGO Arduino"
! le kit "Barrière LEGO Arduino" ne comprend pas les pièces LEGO pour fixer le servomoteur (voir au bas de cette page pour plus de précisions)



Pour 20€ chez LEGO, tu as ça , mais tu peux aussi choisir d'aller voir un peu plus loin et d'apprendre à coder avec le kit "Barrière LEGO Arduino"
 --> commander un kit "Barriere LEGO - Arduino"  
ou envoyez un mail à scenaristeur@gmail.com

La barrière LEGO peut être déclinée sous plusieurs versions, et celles-ci peuvent être combinées :
- 1 la barrière LEGO à partir d'un capteur ultrason.
- 2 la barrière LEGO utilisant la télécommande infrarouge
... a vous de voir ensuite comment vous pouvez améliorer votre barrière LEGO... 😉

Le graphe de la barriere LEGO

Nous allons voir dans un premier temps la version avec le capteur ultrason :

- 1 la barrière LEGO à partir d'un capteur ultrason.

Quand un véhicule passe devant le capteur Ultrason, la barrière se lève pendant trois secondes puis reprend sa position initiale : 




 










Matériel nécessaire :  'KIT Arduino Barrière LEGO'
 --> commander un kit "Barriere LEGO - Arduino"  
ou envoyez un mail à scenaristeur@gmail.com

1 breadboard (ou planche à pain en français ), c'est la plaque où l'on va positionner nos composants et qui nous permettra d'établir les connexions entre ceux-ci.

A l'interieur de la breadbord, des connexions sont déjà établies (traits noirs sur la photo ci-dessous), par exemple, vous pour connecter une broche qui serait connectée en 'A1', vous pouvez utilisez tous les trous de 'B1' à 'E1'. Les trous 'F1' à 'J1' sont également connectés entre eux.

une carte Arduino Uno ou
une carte Arduino Nano avec son cable USB,
ou compatible
un capteur ultrasons HC-SR04 pour capter le passage d'un véhicule
Un servomoteur SG90 pour actionner la barrière
Une dizaine de câbles pour relier tout ça 
Une barre LEGO Technic qui servira de barrière
+ Quelques briques LEGO pour fixer le servomoteur


Repérez les deux lignes à l'extérieur de la breadboard: une rouge et une bleue. Ne les utilisez pas pour l'instant, elles serviront à transmettre le courant pour alimenter les composants.




Effectuer les branchements


1. Commencez par positionner et enficher la carte Arduino et le capteur ultrasons HC-SR04 sur la breadboard :
- la carte Arduino au centre de la breadbord et le capteur sur le bord.

2. Pour alimenter le capteur ultrason HC-SR04, nous allons créer un circuit :
- repérez sur la carte Arduino la broche notée '5V' (c'est le + ) et branchez un fil pour la relier jusqu'à la ligne rouge.
- repérez sur le capteur HC-SR04 la broche notée 'VCC' et reliez la également à la ligne rouge



Dans un deuxième temps :
- repérez sur la carte Arduino une des broches notée 'GND' (c'est le -) et branchez un fil pour la relier jusqu'à la ligne bleue.
- repérez sur le capteur la broche notée 'GND' et reliez-la avec la ligne bleue.

Vous devriez maintenant avoir une carte Arduino, un capteur ultrason HC-SR04 et 4 fils comme sur la photo suivante :




Le capteur HC-SR04 est un capteur ultrason et fonctionne suivant le principe du sonar de la chauve-souris : un ultrason est émis, puis l’écho est réceptionné, la délai entre l’émission et la réception permet de calculer la distance de l'obstacle.
Sur le capteur il reste deux broches : 'Trig' et 'Echo' . Avec deux autres fils, reliez 'Trig' à la broche 'D3' de la carte Arduino et 'Echo' à la broche 'D4' . 'Trig' enverra un ultrason et 'Echo' réceptionnera l'écho...






Passons maintenant à la programmation de la carte Arduino :

Une petite video pour l'installation du logiciel,
Pensez bien à vérifier la configuration de la carte dans le menu 'Outils/ type de carte' et 'Outils/port' (choix de la carte et de son port). Pour plus de précisions ces sujets ont étés maintes fois traités comme ici.



Voici le code de test du capteur HCSR-04 présenté dans la vidéo :
#include <HCSR04.h>

UltraSonicDistanceSensor distanceSensor(3,4);  // Initialize sensor that uses digital pins 13 and 12.

void setup () {
    Serial.begin(9600);  // We initialize serial connection so that we could print values from sensor.
}

void loop () {
    // Every 500 miliseconds, do a measurement using the sensor and print the distance in centimeters.
    Serial.println(distanceSensor.measureDistanceCm());
    delay(500);
}

En allant ensuite consulter le traceur série, vous devriez voir une courbe apparaître :




Maintenant que le capteur est opérationnel, on va pouvoir brancher le servomoteur :
sur un servomoteur, nous avons 3 fils :
- le + (rouge)
- le - (noir ou marron)
- la mesure (jaune ou blanc)

Utilisez trois nouveaux fils pour prolonger ceux issus du moteurs


et connectez ceux-ci de la manière suivante :
le + vers la ligne rouge de la breadboard,
le - vers la ligne bleue de la breadboard
le 3ème vers la broche 'D9' de la carte Arduino




Reprenons maintenant notre code et modifions le pour prend en compte le moteur. On peut s'inspiré de l'exemple 'Knob' comme évoqué dans la vidéo d'installation du logiciel Arduino :

Attention les deux vidéos suivantes se superposent  pour montrer à la fois la partie code et la partie exécution du code :

Confection du code :



Voici le code qui permet de faire fonctionner notre barrière LEGO avec déclenchement par capteur Ultrason :


////////////////////////////////////////////////////////////////////////////////////////
// Le code suivant correspond au tutoriel présenté à cette adresse :                  //
// http://smag0.blogspot.com/2017/06/arduino-barriere-lego.html                       //
// L'objectif est de créér une barrière qui se lève lorsqu'un véhicule passe devant   //
// le capteur ultrason                                                                //
// Pensez à bien vérifier le type de carte et le port COM dans le menu 'Outils'       //
////////////////////////////////////////////////////////////////////////////////////////


/* Import de la librairie pour le capteur ultrason HCSR04
  et pour le servomoteur */
#include <HCSR04.h>
#include <Servo.h>

/* On créé un objet capteur ultrason (UltraSonicDistanceSensor)
  que l'on initialise sur les pins D3 pour TRIG et D4 pour ECHO*/
UltraSonicDistanceSensor capteur_distance(3, 4);

/* Creation d'un objet Servo pour contrôler le servomoteur */
Servo mon_servo;


/*  la fonction setup() permet de mettre en place l'environnement */
void setup () {
  /* - On initialise une connection série pour pouvoir afficher les
 valeurs dans le moniteur ou le traceur (menu Outils).
       - On indique que notre servomoteur est relié à la Pin 9
       - On positionne notre servomoteur à l'horizontale (180°)   */
  Serial.begin(9600);
  mon_servo.attach(9);
  mon_servo.write(180);
}


/* la fonction loop() boucle à l'infini,
 lit la valeur du capteur et actionne le moteur */
void loop () {
  /* on lit la distance en cm mesurée par le capteur grâce
 à la fonction measureDistanceCm de l'objet capteur_distance précédemment créé */
  int distance = capteur_distance.measureDistanceCm(); 
   /* on teste si la valeur est comprise entre 1 cm et 15 cm */   
  if ( distance > 1 && distance < 15 ) {  
    /* Si elle est comprise entre 1 cm et 15 cm
 on l'envoi à la connexion série pour l'afficher dans le moniteur ou le traceur */               
    Serial.println(distance);                            
/* On demande envoi un angle de 90° au servo moteur ce qui doit lever la barrière */ 
    mon_servo.write(90);                                 
    /* et on attend 3000 millisecondes = 3 secondes avant de continuer */
    delay(3000);
  } else {
    /* Sinon, la distance n'est pas comprise entre 1cm et 15 cm,
 on baisse la barrière en positionnant le servomoteur à 180° */
    mon_servo.write(180);                                 
  }
  /* On attend 500 millisecondes avant d'effectuer une nouvelle boucle (loop)
 et de lire la valeur suivante */
  delay(500);                                             
}


Exécution du code :





Qu'est-ce qu'il vous reste à faire ?
Trouver le moyen de fixer le servo-moteur à l'aide de briques et de plaques LEGO, ci dessous un exemple de ce que l'on peut faire :










08/08/2015

DreamCatcher, l'attrape rêves

DreamCatcher est une application gratuite opensource permettant de transmettre des informations aux objets connectes et autres robots de ma maison.
Par extension, elle peut être utilisée pour présenter et partager ses idées entre les humains également ;-) .

La dernière version 1 est accessible ici : http://smag-smag0.rhcloud.com/DreamCatcher .
ou plus facile à retenir (http://goo.gl/tViQ3Q) ... "t'es vicu trois culs avec t et i en minuscule" ;-D
(Le développement sur smartphone n'est pas encore totalement implémenté, à utiliser sur PC avec Chrome ou Firefox).
 [ Nouvelle version en cours de développement avec P5js en 3D : http://smag0.blogspot.fr/2015/12/dreamcatcher-ou-comment-partager-des.html ]

[ v1,v2 ou v3 ? faisons le point sur les versions de Dreamcatcher : http://smag0.blogspot.fr/2016/02/dreamcatcher-v3-integration-dans-meteor.html ]

Historique : 

L'idée de départ était de créer une interface pour le projet Smag0 (un robot qui range ma chambre).

Pour Smag0, nous avons besoin d'une interface simple pour transmettre des informations au robot (ou groupe de robots, objets connectes...) qui serait en mesure de ranger notre chambre, puisque c'est le but du projet.


Pour que ces "futurs hypothétiques robots" communiquent et échangent des informations, il a été pris parti de formater les informations au format RDF/OWL, ces informations décrivent des relations entre deux concepts, plutôt qu'un concept seul, sous forme de triplet.
(voir : Robolution + Homme 2.0 = Information 2.0)



Au départ, donc, cette interface devait servir, pour l'utilisateur, à transmettre facilement des informations à la maison, qui les partagerait ensuite avec les différents robots et objets connectés que l'on pourrait avoir dans notre maison.

Par extension, et au fil des développement, je me suis aperçu qu'elle pouvait également être utile pour exposer ses idées et les visualiser sous forme de graphes. Il est alors plus facile de partager ses idées.
Un petit schéma valant toujours mieux qu'un long discours, le graphe donne la possibilité d'atteindre directement l'information qui nous intéresse, et de cerner rapidement les informations qui sont liées.

Cette application dont le but est de faciliter la captation de mes idées ou de mes rêves a donc un nom tout trouvé : DreamCatcher (Attrape Revês)...

Le code source pour ceux qui voudraient modifier l'application est disponible en bas de la page de l'application.


Utilisation : 

L'utilisation de DreamCatcher est très simple.

Ouverture : 

A l'ouverture, un jeu de données est présent. Il suffit de cliquer dans l'espace de travail pour que le graphe correspondant à ces données prenne forme.
On peut alors zoomer avec la flèche "haut" du clavier et dézoomer avec la flèche "bas". Avec la souris, on peut aussi déplacer le graphe pour consulter une zone particulière.
La barre "espace" de votre clavier rétablit la position initiale.
Voir l'aide pour plus de fonctionnalités (nouveau graphe, sauvegarde du graphe sous forme d'image...)

Les données correspondantes au graphe apparaissent sur la droite sous forme de blocs bleus en dessous de "Dernière Activité".
Elles sont déjà enregistrées sous forme de triplet {sujet, prédicat, objet}.



En cliquant sur l'un de ces blocs bleus, vous le sélectionnez, il passe alors directement dans l'espace "Informations sélectionnées" et devient vert.
En même temps, la partie du graphe correspondant à cette information s'éclaire dans le graphe (si le graphe ne s'actualise pas automatiquement, cliquez à l'intérieur de l'espace de travail) :

  • le sujet du triplet en jaune,
  • la propriété (ou prédicat) en vert,
  • et l'objet du triplet en bleu.

Vous pouvez sélectionner plusieurs informations en même temps et les voir apparaître dans le graphe.
Pour les faire disparaître, il suffit de les désélectionner en cliquant sur le bloc vert correspondant. L'information redescend automatiquement dans l'espace "Dernière Activité" et redevient bleue .


Créer un nouveau Graphe

Pour créer un nouveau graphe, il suffit de cliquer dans l'espace de travail pour être certain qu'il soit bien activé, et de presser la touche "n" de votre clavier. (la touche "d" permet de recharger la démo).

Lorsque vous pressez la touche "n", l'espace de travail est nettoyé, et vous pouvez glisser les blocs "Chose/Thing" dans l'espace de travail pour décrire une nouvelle chose, idem pour "Acteur" et "Environnement"... ("Un type de chose" correspondant à une classe au sens OWL)

D'autres fonctionnalités sont en cours de développement, comme la modification des informations, l'ajout de propriétés à un sujet, la visualisation à différents niveaux, la recherche de liens avec les vocabulaires et bases de données existants (http://wiki.dbpedia.org/online-access/DBpediaLivehttp://lov.okfn.org/dataset/lov/), la création de sessions où l'on peut travailler à plusieurs sur le même graphe, l'utilisation de l'interface DreamCatcher pour fusionner les idées comme évoqué ici : https://www.linkedin.com/pulse/large-concept-collider-georges-le-nigen , une interface mobile permettant d'enregistrer messages vocaux et formater infos pour DreamCatcher...

N'hésitez pas proposer des modifications ou critiquer, proposez également de nouvelles fonctionnalités, et surtout dites-moi ce que vous n'avez pas compris... c'est le meilleur moyen de faire avancer les choses, et de proposer une interface la plus accessible possible pour proposer cette application aussi bien à mon fils de 8 ans qu'à ma grand-mère de 70 ans... ;-) 

Utilisez les commentaires au bas de cet article ou l'espace de discussion prévu à cet effet : https://groups.google.com/forum/#!topic/smag0/HpqEGB7cH4g


Accéder à DreamCatcher http://goo.gl/tViQ3Q

 [ Nouvelle version en cours de développement avec P5js : http://smag0.blogspot.fr/2015/12/dreamcatcher-ou-comment-partager-des.html ]


[... Document en cours de création...]

17/06/2015

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 :

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...















08/06/2015

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.

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.