Smag0

05/02/2017

Arduino contrôler un servomoteur avec un capteur de distance

[[ une nouvelle version de cet article est disponible ici : http://smag0.blogspot.com/2017/06/arduino-barriere-lego.html ]]

Matériel :
- une carte Arduino
- un servomoteur (noir sur grd, rouge sur 5V, jaune sur pin 9)
- un capteur Ultrason HC-SR04 (noir sur grd, rouge sur 5V, trig sur pin 12, echo sur pin 11)

/* Utilisation du capteur Ultrason HC-SR04 pour contrôler un servomoteur*/

#include <Servo.h>

Servo myservo; // create servo object to control a servo

// définition des broches utilisées

int servo = 9;

int trig = 12;

int echo = 11;

long lecture_echo;

long cm;

int val;

long lastCm = 0;

void setup()

{

myservo.attach(servo);

pinMode(trig, OUTPUT);

digitalWrite(trig, LOW);

pinMode(echo, INPUT);

Serial.begin(9600);

}

void loop()

{

digitalWrite(trig, HIGH);

delayMicroseconds(10);

digitalWrite(trig, LOW);

lecture_echo = pulseIn(echo, HIGH);

cm = lecture_echo / 58;

int diff = int(abs(lastCm - cm)); // detection de grand saut

if(diff < 30){ // seulement si diff est faible

val = min(cm,179);

if( val< 179){

Serial.print(diff);

Serial.print(" : ");

Serial.println(val);

myservo.write(val);

}

}

delay(10);

lastCm = cm;

}

25/09/2016

Google Polymer Openfisca Etalab

Un petit tutoriel pour apprendre à utiliser Openfisca de la DGFIP et d'Etalab, à partir de Polymer de Google.

OpenFisca propose une Web Api permettant de calculer prestations sociales, niveau de vie, impôts...
Polymer quand à lui permet de créer de jolies interfaces mobiles ou web à partir de webcomponents.

Prérequis

- Nodejs et npm (installé avec nodejs)

Installation de Polymer-cli

npm install -g polymer-cli

Création d'un dossier de travail

mkdir my-app cd my-app

Création de l'application

polymer init

- choisissez la ligne starter-kit
- l'application polymer doit maintenant être installé, pour vérifier, vous pouvez la lancer en utilisant la commande "polyserve" et elle devrait être accessible à l'adresse http://localhost:8080

Deux dossier nous intéressent maintenant :
- "src", c'est le dossier principal de l'application
- "bower_components", c'est le dossier des éléments de Polymer (webcomponents)

Création de l'élément "openfisca-calcul"

on va se placer dans le dossier "bower_components", créer le dossier de l'élément et créer l'élément encore une fois avec "polymer init".

cd bower_components
mkdir openfisca-calcul
polymer init

et cette fois, on va choisir de créer un élément (a blank template element)

Insertion de l'élément "openfisca-calcul"

Maintenant que notre élément est créé, on peut l'insérer dans notre application.
Allez dans le dossier "src" et ouvrez le fichier "my-view1.html" avec votre éditeur préféré.

Deux étapes sont nécessaire pour insérer un élément : l'import et le positionnement.

L'import :
<link rel="import" href="../bower_components/openfisca-calcul/openfisca-calcul.html">

Le positionnement :
Ajoutez simplement une balise ouvrante fermante représentant l'élément :

<openfisca-calcul></openfisca-calcul>

Profitons en aussi pour supprimer le "<div class="card"> ... </div>" ... on le déplacera dans notre élément

Votre fichier my-view1.html devrait maintenant ressembler à ceci :

 <!--  
 @license  
 Copyright (c) 2016 The Polymer Project Authors. All rights reserved.  
 This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt  
 The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt  
 The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt  
 Code distributed by Google as part of the polymer project is also  
 subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt  
 -->  
 <link rel="import" href="../bower_components/polymer/polymer.html">  
 <link rel="import" href="shared-styles.html">  
 <link rel="import" href="../bower_components/openfisca-calcul/openfisca-calcul.html">  
 <dom-module id="my-view1">  
  <template>  
   <style include="shared-styles">  
    :host {  
     display: block;  
     padding: 10px;  
    }  
   </style>  
      <openfisca-calcul></openfisca-calcul>  
  </template>  
  <script>  
   Polymer({  
    is: 'my-view1'  
   });  
  </script>  
 </dom-module>

Construction de l'élément "openfisca-calcul"

Avec Polymer, on favorise la réutilisation d'éléments déjà existants.

On va ici avoir besoin de trois éléments différents :

- un "paper-button" : un bouton pour lancer le calcul,

- un "iron-ajax" qui se chargera d'effectuer la requête vers l'adresse web de l'API d'Openfisca (https://api.openfisca.fr/api/1/calculate)

- un petit "paper-spinner" pour nous indiquer que l'application est en train de traiter la requete.

L'installation de ces trois éléments se fait tout simplement : commencer par vous positionner à la racine de votre application, là où se trouve le fichier "bower.json"

bower install --save paper-button iron-ajax paper-spinner

Maintenant que ces trois éléments sont disponibles pour notre application, il ne nous reste plus qu'à les intégrer... et leur tour est joué... enfin faudra aussi taper un peu de code, on est là pour ça, quand-même...

Pour l'intégration, on opère comme avec le fichier my-view1.html.
Editez le fichier "openfisca-calcul.html" situé dans "my-app/bower_components/openfisca-calcul", et ajoutez au début les lignes suivantes :

Ajoutez par la même occasion la ligne suivante qui nous permettra de gérer les styles :

Tant qu'on est sur les styles, intégrons les en modifiant la balise <style>...< /style> ( dans le fichier "my-app/bower_components/openfisca-calcul/openfisca-calcul.html") et en la remplaçant par :

           <style include="shared-styles">  
                :host {  
                display: block;  
                padding: 10px;  
                }  
           </style>

Après la balise <style> ainsi modifiée, insérée l'élément concernant la requête ajax en utilisant le code suivant :

           <iron-ajax  
           id="ajaxcalculate"  
           url="https://api.openfisca.fr/api/1/calculate"  
           body="{{data2send}}"  
           method="POST"  
           handle-as="json"  
           content-type="application/json"  
           on-response="handleResponse">  
           </iron-ajax>

Quelques explications s'imposent :

<iron-ajax>...</iron-ajax> : nous permet d'insérer l'élément iron-ajax qui s'occupe d'effctuer la requête.
id="ajaxcalculate" : un id qui nous permettra d'identifier la requete lors de l'appui sur le bouton "Calcul"
url="https://api.openfisca.fr/api/1/calculate" : l'adresse url vers laquelle la requête va être envoyée
body="{{data2send}}" : représente les données qui vont être envoyées à l'adresse url
method="POST" : l'API openfisca n'accepte que le requêtes de type "POST"
handle-as="json" : le format dans lequel on souhaite récupérer les données
content-type="application/json" : le format dans lequel les données sont envoyées à l'API
on-response="handleResponse" : la fonction "callback" exécutée lors les résultats arrivent de l'API

Et bien voilà... on a fait le principal, ne reste plus qu'à formater les données à envoyer et traiter les données reçues...

Tant qu'on y est, profitez-en pour insérer deux <div> : un pour le bouton "calcul" et un pour le résultat :

           <div class="card">  
                <div class="circle">0</div>                 
                <paper-button raised on-tap="calcul" value="CALCUL">CALCUL <paper-spinner id="spinner" alt="Calcul en cours"></paper-spinner></paper-button>  
           </div>  
           <div class="card">  
                <div class="circle">10</div>  
                <h1>Résultat</h1>  
                <p>Revenu disponible 2015 : {{revenuDisponible}} </p>  
           </div>

Données à envoyer et résultat

Pour les données à insérer, il faut avouer que c'est un peu compliqué de communiquer avec l'API Openfisca, mais on y arrive :
Un objet JSON (JSONObject) avec un tableau (JSONArray) nommé "scenarios" et les "variables" que l'on souhaite obtenir en sortie.
Dans le scenario, on trouve un objet "testcase" et un/des "périodes".
Dans le testcase, on défini : "familles", "foyers_fiscaux", "menages" et "individus"...
Pour simplifier ici, on va prendre l'exemple fourni par la documentation d'Openfisca.
On défini les données que l'on va envoyer : "data2send" et les données que l'on aura en résultat : "revenuDisponible"

                     data2send : {  
                          type : Object,  
                          value : {  
                               "scenarios": [  
                               {  
                                    "test_case": {  
                                         "familles": [  
                                         {  
                                              "parents": ["individu0"]  
                                         }  
                                         ],  
                                         "foyers_fiscaux": [  
                                         {  
                                              "declarants": ["individu0"]  
                                         }  
                                         ],  
                                         "individus": [  
                                         {  
                                              "date_naissance": "1980-01-01",  
                                              "id": "individu0"  
                                         }  
                                         ],  
                                         "menages": [  
                                         {  
                                              "personne_de_reference": "individu0"  
                                         }  
                                         ]  
                                    },  
                                    "period": "2015"  
                               }  
                               ],  
                               "variables": ["revdisp","nivvie_net"]  
                          }  
                     },  
                     revenuDisponible : {  
                          type : String,  
                          value : ""  
                     }

C'est presque terminé : il reste la fonction callback lorsque l'application reçoit le résultat et le bouton pour lancer la requête :

                /**  
                     * recupere et parse la reponse du serveur  
                     */  
                     handleResponse: function(data,error){  
                          var result=data.detail.response.value;  
                          console.log("RESULTATS");  
                          console.log(result);                 
                          this.$.spinner.active=false;  
                          for (var key in result) {  
                               if (result.hasOwnProperty(key)) {  
                                    var valeur=result[key];  
                                    console.log(key+" :");  
                                    console.log(valeur);  
                               }  
                          }                 
                          // entrer ensuite dans result pour avoir les details :   
                          //     console.log(result[0].menages[0].revdisp[2015]);  
                          for (var i in result){  
                               var resultat = result[i];  
                               console.log("Revenu disponible 2015 : "+resultat.menages[0].revdisp[2015]);  
                               console.log("Niveau de vie net 2015 : "+resultat.menages[0].nivvie_net[2015]);  
                               this.revenuDisponible=resultat.menages[0].revdisp[2015];  
                          }  
                     },

                          calcul : function(){  
                               console.log(this.data2send);  
                               this.$.spinner.active=true;  
                               this.$.ajaxcalculate.generateRequest();       
                          }

Et voilà... le tour est joué... y'a plus qu'à cliquer sur le bouton "CALCUL"....
Allez ... si j'étais pas très clair, je vous donne le code du fichier "openfisca-calcul"... A vous d'en faire bon usage... comme par exemple un comparateur de prestations en fonction de votre situation ...

 <link rel="import" href="../polymer/polymer.html">  
 <link rel="import" href="../../src/shared-styles.html">  
 <link rel="import" href="../iron-ajax/iron-ajax.html">  
 <link rel="import" href="../paper-button/paper-button.html">  
 <link rel="import" href="../paper-spinner/paper-spinner.html">  
 <!--  
      `openfisca-calcul`  
      @demo demo/index.html   
 -->  
 <dom-module id="openfisca-calcul">  
      <template>  
           <style include="shared-styles">  
                :host {  
                display: block;  
                padding: 10px;  
                }  
           </style>  
           <iron-ajax  
           id="ajaxcalculate"  
           url="https://api.openfisca.fr/api/1/calculate"  
           body="{{data2send}}"  
           method="POST"  
           handle-as="json"  
           content-type="application/json"  
           on-response="handleResponse">  
           </iron-ajax>   
           <div class="card">  
                <div class="circle">0</div>                 
                <paper-button raised on-tap="calcul" value="CALCUL">CALCUL <paper-spinner id="spinner" alt="Calcul en cours"></paper-spinner></paper-button>  
           </div>  
           <div class="card">  
                <div class="circle">10</div>  
                <h1>Résultat</h1>  
                <p>Revenu disponible 2015 : {{revenuDisponible}} </p>  
           </div>  
      </template>  
      <script>  
           Polymer({  
                is: 'openfisca-calcul',  
                properties: {  
                     data2send : {  
                          type : Object,  
                          value : {  
                               "scenarios": [  
                               {  
                                    "test_case": {  
                                         "familles": [  
                                         {  
                                              "parents": ["individu0"]  
                                         }  
                                         ],  
                                         "foyers_fiscaux": [  
                                         {  
                                              "declarants": ["individu0"]  
                                         }  
                                         ],  
                                         "individus": [  
                                         {  
                                              "date_naissance": "1980-01-01",  
                                              "id": "individu0"  
                                         }  
                                         ],  
                                         "menages": [  
                                         {  
                                              "personne_de_reference": "individu0"  
                                         }  
                                         ]  
                                    },  
                                    "period": "2015"  
                               }  
                               ],  
                               "variables": ["revdisp","nivvie_net"]  
                          }  
                     },  
                     revenuDisponible : {  
                          type : String,  
                          value : ""  
                     }       
                },  
                /**  
                     * recupere et parse la reponse du serveur  
                     */  
                     handleResponse: function(data,error){  
                          var result=data.detail.response.value;  
                          console.log("RESULTATS");  
                          console.log(result);                 
                          this.$.spinner.active=false;  
                          for (var key in result) {  
                               if (result.hasOwnProperty(key)) {  
                                    var valeur=result[key];  
                                    console.log(key+" :");  
                                    console.log(valeur);  
                               }  
                          }                 
                          // entrer ensuite dans result pour avoir les details :   
                          //     console.log(result[0].menages[0].revdisp[2015]);  
                          for (var i in result){  
                               var resultat = result[i];  
                               console.log("Revenu disponible 2015 : "+resultat.menages[0].revdisp[2015]);  
                               console.log("Niveau de vie net 2015 : "+resultat.menages[0].nivvie_net[2015]);  
                               this.revenuDisponible=resultat.menages[0].revdisp[2015];  
                          }  
                     },  
                     /**  
                          *  
                          */  
                          calcul : function(){  
                               console.log(this.data2send);  
                               this.$.spinner.active=true;  
                               this.$.ajaxcalculate.generateRequest();       
                          }  
                     });  
                </script>  
           </dom-module>

Le code source est téléchargeable ici https://github.com/scenaristeur

Des questions ? des erreurs ? utilisez les commentaires ci-dessous ou le forum de l'article

07/09/2016

Sparql update un Polymer element pour mettre a jour un sparql endpoint

Objectif de cet article : Créer un element Polymer pour mettre à jour un sparql endpoint (fuseki)

inspiration : https://www.youtube.com/watch?v=k1eR_3KqJms

premier test : sparql-statements (recupérer les infos RDF sur un serveur sparl / fuseki en utilisant iron-ajax)

serveur fuseki : http://rdf-smag0.rhcloud.com/

prérequis :
installation de nodejs, yeoman

Polymer propose polymer:seed, un element modèle servant d'exemple pour la création d'elements Polymer.

Au boulot on va créer un element "sparql-update"
sous l'invite de commande dos tapez :

yo polymer:seed sparql-update

complétez avec vos infos -6> un module modèle est créé dans votre repertoire.
Pour le lancer utilisez la commande : polyserve

Le nouvel element généré est accessible à l'adresse :
http://localhost:8080/components/sparql-update

quelques soucis parfois d'affichage, (un certain temps pour mettre à jour ? allez voir dans le fichier README.RD généré pour avoir différents liens et testez notamment celui-ci : http://localhost:8080/components/sparql-update/test/ ) , une page de tests devrait finir par s'afficher.

Ce qui nous intéresse, Thérèse , ensuite c'est le module lui-même, on utilisera deux pages :

la page du module : http://localhost:8080/components/sparql-update/
la page de demo accessible par le bouton "DEMO" en haut à droite

Laisser le terminal ou vous avez lancez polyserve ouvert et ouvrez un autre terminal pour installer l'element "iron-ajax" avec la commande :

bower install --save PolymerElements/iron-ajax

et incorperez cet element dans sparql-update.html avec : <link rel="import" href="../iron-ajax/iron-ajax.html"> juste après <link rel="import" href="../polymer/polymer.html">

supprimer les elements inutiles dans le modeles :

dans le fichier sparql-update.html

.author dans template/style

et ne garder que "properties" dans la definition js de l'element :

il ne devrait vous rester plus que ceci :

<dom-module id="sparql-update">

<style>

:host {

display: block;

box-sizing: border-box;

}

</style>

</template>

Polymer({

is: 'sparql-update',

properties: {

}

});

</script>

</dom-module>

Nous avons maintenant un élement propre et on va pouvoir y mettre notre propre (ou sale ?) code

On incorpore maintenant notre element "iron-ajax" qui va se charger d'effectuer la requete POST vers notre serveur Fuseki :

<iron-ajax/iron-ajaxauto
url=""
handle-as="json"
on-response="{{handleResponse}}"></iron-ajax>

le mieux c'est de jeter un oeil au code

26/08/2016

Question reponse avec Polymer Firebase Collection

source https://divshot.com/blog/web-components/building-a-qa-system-with-polymer-and-firebase/
updated to polymer 1.0.0

npm install -g yo

npm install -g generator-polymer

yo polymer

gulp serve ( a la place de grunt serve)

ne pas supprimer elements.html , mais lui rajouter une ligne :

<link rel="import" href="qa-app/qa-app.html">

creation d'une <qa-app> dans app/elements avec ce code :

<link rel="import" href="../../bower_components/polymer/polymer.html">
<link rel="import" href="../../bower_components/paper-styles/typography.html">

<dom-module id="qa-app">
  <template>
    <style include="shared-styles">
      :host {
        display: block;
      }

     <!-- span,
      input {
        @apply(--paper-font-body2);
  }-->
    </style>

  <!-- <h1 class="page-title" tabindex="-1">{{greeting}}</h1>
    <label for="greeting-input">Update text to change the greeting.</label>
    <!-- Listens for "input" event and sets greeting to <input>.value -->
   <!-- <input id="greeting-input" value="{{greeting::input}}"> -->
  </template>

  <script>
    (function() {
      'use strict';

      Polymer({
        is: 'qa-app',

       /* properties: {
          greeting: {
            type: String,
            value: 'Welcome!',
            notify: true
          }
        }*/
      });
    })();
  </script>
</dom-module>

insertion dans index.html :

  <paper-material elevation="1">
    <qa-app></qa-app>
    </paper-material>

Au lieu de core-components (<0.8) utiliser bower install --save

en ayant pris soin de corriger le fichier bower.json ainsi :

{
  "name": "polymer1-qa",
  "authors": [
    "D.FAVERIS"
  ],
  "private": true,
  "dependencies": {
    "iron-elements": "PolymerElements/iron-elements#^1.0.0",
    "neon-elements": "PolymerElements/neon-elements#^1.0.0",
    "page": "visionmedia/page.js#^1.6.4",
    "paper-elements": "PolymerElements/paper-elements#^1.0.1",
    "platinum-elements": "PolymerElements/platinum-elements#^1.1.0",
    "polymer": "Polymer/polymer#^1.6.0"
  }
}

ajustez les imports ainsi :

<link rel="import" href="../../bower_components/polymer/polymer.html">
<link rel="import" href="../../bower_components/paper-styles/typography.html">

<link rel="import" href="../../bower_components/paper-header-panel/paper-header-panel.html">
<link rel="import" href="../../bower_components/paper-toolbar/paper-toolbar.html">
<link rel="import" href="../../bower_components/iron-icons/social-icons.html">
<link rel="import" href="../../bower_components/paper-menu/paper-menu.html">
<link rel="import" href="../../bower_components/paper-dropdown-menu/paper-dropdown-menu.html">
<link rel="import" href="../../bower_components/paper-icon-button/paper-icon-button.html">
<link rel="import" href="../../bower_components/paper-menu-button/paper-menu-button.html">
<link rel="import" href="../../bower_components/paper-item/paper-item.html">

<dom-module id="qa-app">
  <template>

...

bower install --save firebase/polymerfire a la place de
bower install Polymer/firebase-element --save

Voir avec PolyUp pour upgrader un module Polymer 0.5 en Polymer 1.0

03/08/2016

Integration en entreprise du Bigdata, iot, ia, machine learning, robotique

L'intégration de nouvelles technologies telles que Bigdata, objets, robotique, machine learning ou intelligence artificielle dans une entreprise soulève de nombreuses questions.

Les nouvelles technologies nous attirent, donnent envie, proposent dans l'absolu de nouvelles possibilités d'optimisation, une meilleure gestion des ressources, une amélioration des conditions de travail...

Mais quelles sont les technologies dont vous avez réellement besoin ?
Quelles sont les priorités ?
L'investissement en vaut-il la chandelle ?
Et si oui, par quel bout les aborder ?

Ces nouveaux outils sont à considérer comme de nouvelles ressources que peut utiliser l'entreprise, au même titre qu'un véhicule ou qu'un employé.
De part la prise de décision que ces outils proposent, ils sont même plus proche d'un employé, que d'un véhicule ( le déploiement massif des véhicules autonomes n'étant pas encore opérationnel ;-) )

La grosse question est de déterminer le degré d'autonomie que l'on va vouloir attribuer à ces nouveaux outils...

En effet, selon les cas, on souhaitera que tel outil soit une simple aide à la manipulation, ou à la décision, soit une autonomie complète, avec entre les deux tous les degrés possibles d'autonomie...

Parfois, selon le contexte, selon les circonstances, ce degré d'autonomie devra même être modifié.

Le degré d'autonomie d'un outil dépend en grande partie du degré d'intelligence qu'il lui a été attribué, de sa capacité à obtenir des informations de son environnement ( votre entreprise ) , de sa manière de les exploiter, de sa façon de les communiquer...

Un simple capteur thermique ( iot de base ) possède sa propre intelligence, et le choix du matériel à utiliser et son l'intégration dépendront de ses capacités, ses limites...

L'intégration de systèmes plus évolués tels que le machine learning ou l'intelligence artificielle pose de nouvelles questions et se rapproche plus de l'apprentissage comme on pourrait le rencontrer lors des jeunes années d'un enfant. Ces systèmes ont besoin d'informations au sujet de l'entreprise, selon les cas, il s'agira d'un catalogue de produits, de la structure de l'entreprise ou des compétences des autres ressources disponibles ( compétences d'un employé, disponibilité d'un véhicule... )

La majeur partie de l'intégration consiste donc à élaborer des interfaces permettant l'échange de données structurées entre les ressources, qu'elles soient humaines ( les employés ) ou issues des nouvelles technologies, en prenant bien en considération le rôle de chacun...

Par exemple, un employé de la compta n'aura pas les mêmes besoins d'informations qu'un commercial... L'un souhaitera connaître le kilométrage parcouru par un véhicule, alors que l'autre souhaitera connaître sa disponibilité...

L'intégration de ses nouveaux outils commence par une description des ressources existantes, de leurs capacités, de leur besoins, de leurs rôles, et des autres ressources qu'elles utilisent.

Le format de données RDF (principalement utilisé pour le web-semantique ou les énormes bases de connaissance médicales ) et ses extension est une approche simple, open-source, facile à mettre en oeuvre et peut constituer soit une première marche, soit un complément non negligeable dans l'intégration de ces outils.

Le développement récent de l'interface Dreamcatcher de Smag0 permet déjà d'élaborer de manière simple, collaborative, évolutive, ( et parfois même ludique) des bases de connaissance exploitables par ces nouveaux outils.

De nouvelles interfaces (mobiles, tactiles, basées sur la voix, les mouvements... ) peuvent également être développés en fonction des besoins spécifiques de vos collaborateurs de leur rôle et de leur besoins.

Pour une étude des possibilités applicables à votre entreprise en matière d'intégration et d'exploitation des nouvelles technologies n'hésitez à prendre contact avec nos spécialistes DataScientists :

Service commercial : smag0@outlook.fr
Nous suivre sur twitter, rester informé : @dfaveris
Support : 0671578914

01/08/2016

What would happen if the political and government become " Agile " ?

If they used DreamCatcher - Collaborative for the views of citizens on an issue or a new project?

English link : Dreamcatcher ... and life became Agile

En français : DreamCatcher ... Et la vie devint Agile