Tag Linux - Constellation

Un capteur de luminosité extérieur piloté par un Raspberry avec un package Python

Sebastien Warin — Sat, 13 May 2017 12:46:15 +0000

Dans un précédent tutoriel, nous avons découvert comment créer un capteur de luminosité avec un ESP8266 connecté par Wifi. Ici je vous propose de créer un capteur extérieur piloté par un Raspberry Pi.

Pour être exact, le Raspberry Pi sera installé en intérieur, connecté au réseau filaire Ethernet et relié par un câble à un boitier étanche installé sur le toit qui contiendra une photorésistance et/ou un capteur TSL2561.

Nous allons utiliser un Raspberry B+ version 1 sur lequel nous installerons une sentinelle pour pouvoir déployer notre package depuis Visual Studio. Le package d’acquisition des données sera écrit en Python.

Prérequis

Un serveur Constellation
Un Raspberry Pi sur lequel nous installerons une sentinelle
Une photorésistance avec un condensateur 1uF et/ou un capteur TSL2561
Visual Studio avec le SDK Constellation

Mesurer la luminosité ambiante avec une photorésistance

Le montage

Tout d’abord, il nous faut un boitier étanche avec un couvercle transparent (pour mesurer la luminosité c’est mieux !) :

Sur une plaque epoxy, soudons la photorésistance avec un condensateur 1uF.

Une des deux pattes de la photorésistance sera reliée sur la pin « 3v3 » du Raspberry et la deuxième sera reliée à une entrée du Raspberry, disons la pin n°12 (soit la GPIO #18). Toujours sur cette 2ème patte, on soudera le pole « + » du condensateur. L’autre pole du condensateur, celle marquée « -« , devra être reliée à la masse, sur l’une des pins « GND » du Raspberry.

On a donc trois fils connectés entre le Raspberry et notre capteur : le 3V3 et la masse (Gnd) pour l’alimentation et un pour le signal (GPIO #18). L’idée est donc de « charger » le condensateur et de chronométrer le temps qu’il mets à se décharger.

Plus il y a de lumière et moins la résistance est forte, autrement dit le condensateur se déchargera très rapidement. A l’inverse, plus il fait sombre et plus la résistance sera forte. Autrement dit, moins il y a de lumière et moins vite se déchargera le condensateur.

On voit sur les photos ci-dessous, le fil Orange pour le 3V3, le fil Bleu pour la GPIO et le fil Blanc pour la masse (Gnd) :

Il fois les connexions réalisées, on peut refermer proprement notre boitier en vérifiant soigneusement son étanchéité avant de l’installer sur le toit.

Côté intérieur, on relie les 3 fils de notre boitier au Raspberry (3v3, Gnd et GPIO18), le câble Ethernet et l’alimentation MicroUSB.

Pour l’installation du système sur le Raspberry suivez ce guide puis installez-y une sentinelle. Votre Raspberry est prêt et connecté à Constellation, reste à développer notre package Python.

Programmation

Depuis Visual Studio, créons un nouveau projet de type « Constellation Python Package » que nous nommerons “LightSensor”.

Renommez le fichier « Demo.py » en « Light.py » et remplacez l’intégralité du contenu par le code suivant :

import Constellation
import RPi.GPIO as GPIO, time, os      

MAX_READING = 30000
LIGHT_SENSOR_GPIO = 18
MEASURE_INTERVAL = 10

def OnExit():
    GPIO.cleanup()

def RCtime (RCpin):
    reading = 0
    GPIO.setup(RCpin, GPIO.OUT)
    GPIO.output(RCpin, GPIO.LOW)
    time.sleep(0.1) 
    GPIO.setup(RCpin, GPIO.IN)
    # This takes about 1 millisecond per loop cycle
    while (GPIO.input(RCpin) == GPIO.LOW):
        if (reading > MAX_READING):
            break
        reading += 1
    return reading
 
def Start():
    global INTERVAL
    GPIO.setmode(GPIO.BCM)
    Constellation.OnExitCallback = OnExit
    lastSend = 0
    currentValue = 0
    count = 0
    Constellation.WriteInfo("LightSensor is ready !")
    while Constellation.IsRunning:
        currentValue = currentValue + RCtime(LIGHT_SENSOR_GPIO)
        count = count + 1
        ts = int(round(time.time()))
        if ts - lastSend >= int(Constellation.GetSetting("Interval")):
            avg = int(round(currentValue / count))
            Constellation.PushStateObject("Light", avg, "int")
            currentValue = 0
            count = 0
            lastSend = ts
        time.sleep(MEASURE_INTERVAL)

Constellation.Start(Start)

N’hésitez pas à relire le guide sur la création de package Python pour bien comprendre les bases d’un package Python.

Ici on démarre notre package par la méthode « Start » qui démarre une boucle pour appeler la méthode RCtime toutes les 10 secondes (variable MEASURE_INTERVAL).

La méthode RCtime charge le condensateur (mode output) puis passe l’I/O en « input » et incrémente la variable « reading » en continue tant que le condensateur n’est pas déchargé (input == « low »). Plus la valeur « reading » est élevée, plus le condensateur a mis du temps à se décharger et donc moins il y a de lumière. On a un garde-fou à « 30.000 » pour ne pas attendre indéfiniment dans le cas où il fait trop sombre.

Bien entendu on ne mesure pas une unité précise. Si vous déployez votre code sur un RPi V1 et V2 (plus puissant), vous n’aurez pas la même valeur pour les mêmes conditions.

Chaque mesure incrémente la variable « currentValue », puis dès qu’on atteint l’intervalle configuré dans les Settings Constellation, on fait la moyenne des mesures on publie un StateObject nommé « Light » de type « int ».

Dans le manifeste du package (PackageInfo.xml), n’oubliez pas de déclarer le setting « Interval » en lui spécifiant une valeur par défaut, ici de 10 seconde :

De même vous pouvez également modifier les informations de compatibilité des plateformes pour exclure la plateforme Windows dans la mesure où le package exploite les GPIO du Raspberry.

Et voilà le package est prêt, vous pouvez depuis Visual Studio le publier dans votre Constellation :

… puis le déployer sur votre sentinelle Raspberry depuis la Console Constellation, en cliquant sur le bouton “Deploy new package” :

Dans l’assistant de déploiement vous pourrez alors personnaliser le setting “Interval” ou bien laisser la valeur par défaut que nous avons fixé à 10 (secondes) :

Sur la Console Log, le package va être téléchargé et déployé par votre sentinelle Raspberry avant de démarrer :

Et en vous rendant dans le StateObjects Explorer, vous verrez votre package “LightSensor” publier un StateObject “Light” avec un entier comme valeur :

Votre package Python est opérationnel, on peut dés à présent exploiter cette valeur dans une page Web, un script, un programme .NET ou Python, un Arduino, etc… comme nous le verrons dans la suite de cet article.

Mesurer des lux avec un capteur TSL2561

Pour obtenir une mesure plus fiable et surtout exploitant une échelle de mesure universelle, nous allons utiliser un capteur de luminosité TSL2561 capable de mesurer des Lux.

Le montage

Dans cette deuxième version, j’ai conservé la photorésistance et simplement ajouté le capteur TSL2561. Celui-ci est également alimenté en 3V3, j’ai donc réutilisé les deux fils (Orange et Blanc) de la photorésistance pour alimenter le capteur également.

Le TSL2561 utilise l’I²C, j’ai donc ajouté deux fils entre le boitier étanche et le Raspberry pour connecter le capteur en i²C (SDA et SCL).

Sur le Raspberry, le SDA est la GPIO#2 et le SCL la GPIO #3, c’est à dire juste en dessus de la pin 3v3.

La programmation

Le plus simple et le plus fiable pour récupérer les données du capteur TSL2561 depuis un Raspberry est d’utiliser un programme natif. Pour cela nous allons utiliser le code publié à cette adresse : http://dino.ciuffetti.info/2014/03/tsl2561-light-sensor-on-raspberry-pi-in-c/.

Il suffit récupérer les 3 fichiers C et de les compiler avec GCC pour générer le binaire. Pour vous simplifier la tache, vous pouvez directement récupérer le binaire GetTSL2561 ici.

Ajoutez ensuite un deuxième script nommé « Lux.py » dans le répertoire « Scripts » de votre projet et n’oubliez pas d’inclure votre script dans le package en définissant la Build Action à « Content » et en activant la copie du fichier dans le répertoire de sortie :

Copiez également le binaire GetTSL2561 dans le répertoire « Scripts » de votre package en l’incluant également dans le package (Build Action à Content et Copy if newer).

Le contenu du script « Lux.py » sera :

import Constellation
import os, re, subprocess, time, stat

# Const
EXECUTABLE_FILENAME = "GetTSL2561"

def DoMeasure():
    # Start process
    process = subprocess.Popen("./" + EXECUTABLE_FILENAME, stdout=subprocess.PIPE)
    # Reading  output
    for line in iter(process.stdout.readline, ''):
        # Parse line
        matchObj = re.match('RC: (\d*)\((.*)\), broadband: (\d*), ir: (\d*), lux: (\d*)', line)
        if matchObj:
            # Reading value
            returnCode = int(matchObj.group(1))
            broadband = int(matchObj.group(3))
            ir = int(matchObj.group(4))
            lux = int(matchObj.group(5))
            # Push StateObject
            if returnCode != 0:
                Constellation.WriteWarn("Unknow return code %s : %s" % (returnCode, line))
            else:
                Constellation.PushStateObject("Lux", { "Broadband": broadband, "IR" : ir, "Lux" : lux }, "LightSensor.Lux")
        else:
            Constellation.WriteError("Unable to parse the output: %s" % line)

def Start():    
    # Make the "GetTSL2561" file as executable
    st = os.stat(EXECUTABLE_FILENAME)
    os.chmod(EXECUTABLE_FILENAME, st.st_mode | stat.S_IEXEC)
    Constellation.WriteInfo("LuxSensor is ready !")
    while Constellation.IsRunning:  
        DoMeasure()
        time.sleep(int(Constellation.GetSetting("Interval")))

Constellation.Start(Start)

Comme pour le script « Light.py », on déclare la méthode « Start » comme méthode de démarrage. Celle-ci boucle tant que le package est démarré à l’intervalle défini par le setting « Interval » qu’on a déclaré à 10 secondes par défaut dans le manifeste.

A chaque itération, on invoque la méthode « DoMeasure » qui démarre le programme « GetTSL2561 » et on parse avec une regex le résultat de la sortie du programme (process.stdout) pour extraire le code de retour, le broadband (spectre visible), l’infrarouge et le nombre de lux courant mesuré par le capteur.

Si le code de retour est égal à 0 c’est que la mesure est correcte, on publie alors un StateObject nommé « Lux » contenant les trois propriétés mesurées : Broadband, IR et Lux.

Constellation.PushStateObject("Lux", { "Broadband": broadband, "IR" : ir, "Lux" : lux }, "LightSensor.Lux")

Attention avant de déployer cette nouvelle version il faut activer l’I²C sur le Raspberry. Pour cela lancer la commande « sudo raspi-config » puis dans le menu « Advanced Options » activez l’I²C et chargez le module par défaut au démarrage.

On peut maintenant publier cette nouvelle version depuis Visual Studio et lancer un « Reload » sur notre package pour déployer cette nouvelle version sur notre Rapsberry.

Désormais nous avons deux StateObjects publiés par ce package : « Light » via la photorésistance et « Lux » via le TSL2561 :

Notre nouveau StateObject « Lux » est un objet complexe contenant trois propriétés :

Exploitez les données

Notre package Python vit sa vie sur notre Raspberry et publie à intervalle régulier deux StateObjects sur base des mesures réalisées par la photorésistance et/ou le capteur de lux TSL2561.

On peut maintenant écrire des pages Web, des scripts, des packages .NET ou Python, Arduino, etc… qui exploiteront ces mesures en temps réel.

Un dashboard Web

Depuis une page Web, il suffit d’ajouter un StateObjectLink. Vous pouvez vous inspirer de ce tutoriel par exemple.

constellation.registerStateObjectLink("*", "LightSensor", "Lux", "*", function (so) {
  $scope.$apply(function () {
    console.log("Lux = ", so.Value.Lux);
  });
});

Par exemple sur le projet S-Panel avec quelques composants Bootstrap :

Un programme .NET

Vous pouvez là aussi vous inspirer de ce tutoriel. En clair, il suffit dans votre code C# d’ajouter des StateObjectLinks avec l’API.NET :

[StateObjectLink("LightSensor", "Lux")]
public StateObjectNotifier Lux { get; set; }

Ainsi la propriété .NET nommée « Lux » ci-dessus sera liée en temps réel au StateObject « Lux » du package « LigthSensor ».

Vous pouvez ajouter des événements dès que la valeur change :

this.Lux.ValueChanged += (s, e) =>
{
    PackageHost.WriteInfo($"Nouvelle mesure à {this.Lux.Value.LastUpdate} = {this.Lux.DynamicValue.Lux} lux");
};

Vous pouvez ainsi faire ce que bon vous semble avec cette information. Par exemple allumer automatiquement les lumières si la luminosité est trop faible, fermer les volets, enregistrer la valeur des Lux dans un fichier Excel ou une base de données, etc.. etc..

Historisation avec ElasticSearch / Kibana

En utilisant le package Graylog du catalogue de package, on peut historiser les mesures de notre capteur dans une base ElasticSearch.

Dans la configuration du package Graylog, on aura quelque chose comme :

La documentation du package Graylog est disponible ici. En résumé on crée ici un abonnement pour la StateObject « Lux » du package « LightSensor » et dans les « outputs » on a déclaré notre serveur Graylog.

De ce fait dès que le StateObject « Lux » est mis à jour par notre package Python, le package Graylog enregistre la nouvelle version du StateObject sur le serveur Graylog qui lui-même utilise ElasticSearch comme base de stockage.

Ainsi on pourra utiliser un outil comme Kibana pour visualiser l’évolution de notre StateObject :

Un article complet sur le sujet a été publié ici.

Stats avec Cacti

On peut également écrire un script pour récupérer notre StateObject « Lux » depuis l’interface REST qu’on ajoutera en tant que « Data Input Methods » dans Cacti pour pouvoir créer des graphiques facilement :

The post Un capteur de luminosité extérieur piloté par un Raspberry avec un package Python appeared first on Constellation.

Jeu de fléchettes connecté à Constellation

Sebastien Warin — Sun, 20 Nov 2016 18:44:59 +0000

Projet réalisé par Buguel Maxime, Cartiaux Charles, Douillard Thomas et Roeland Quentin en Novembre 2016.

Introduction

Nous sommes quatre étudiants en Master 2 à l’ISEN Lille. Nous nous sommes récemment découverts une passion pour les fléchettes, surement lié à la présence d’une cible dans le bar que nous fréquentons (avec modération) après les cours.

La découverte de cette nouvelle passion nous a poussé à ressortir du placard les cibles avec lesquelles nous avons pu jouer étant plus jeunes. Mais le plaisir de jouer aux fléchettes n’était pas le même. C’est vrai que l’écran LCD de 2cm par 4cm et le haut parleur 8-bit n’offre pas la même ambiance que celle que nous pouvons avoir sur une borne de bistrot.

Il existe de nombreux tutoriel pour se créer une borne d’arcade chez soi pour les fans de rétro-gaming mais nous n’avons rien trouvé pour “pimper” notre jeu de fléchettes, mis à part un article de blog qui sans expliquer les détails de la transformation nous a servie de “Preuve de faisabilité”.

Mais nous avons décidé d’aller un peu plus loin que de simplement améliorer l’expérience utilisateur en optimisant l’affichage ainsi que les effets sonores. Afin d’intégrer la cible comme un objet connecté à part entière, Constellation a été utilisé

Connecter la cible

Côté matériel la première étape est de faire l’acquisition d’une cible électronique (bas de gammes afin de limiter les coûts), nous avons choisis le jeu de fléchette le moins chère que l’on ai pu trouver : 19,99 euros.

La détection d’une fléchette par la cible se fait à l’aide de 2 nappes en plastiques séparées par une épaisseur en mousse trouée.

On remarque que le jeu est divisé en 2 moitiés (Par l’axe qui passe entre la zone 9 et 14) l’une des 2 nappes en plastique contient 7 pistes conductrices:

une pour toutes les zones “Simple” de la moitié de la cible
une pour toutes les zones “Simple” de l’autre moitié de la cible
une pour toutes les zones “Double” de la moitié de la cible
une pour toutes les zones “Double” de l’autre moitié de la cible
une pour toutes les zones “Triple” de la moitié de la cible
une pour toutes les zones “Triple” de l’autre moitié de la cible
une pour le “Bull” Simple et Double

L’autre nappe contient 10 pistes, 8 des pistes correspondent chacune à une paire de zone numérotée, chacune des zones appartenant à une moitié différente ((9, 14) par exemple). Les 2 pistes restantes ont, en plus de la paire de zone, une zone du “Bull”.

On se retrouve donc avec ce tableau qui permet de déterminer quelle zone a été touchée. Il suffit d’alimenter les 7 pistes “OUT” une par une et de lire l’état des 10 pistes “IN”. Si on voit que l’une des pistes IN est alimenté alors on peut en déduire la zone touchée.

OUT \ IN	9 14 DB	12 11 SB	5 8 –	20 16 –	10 15 –	2 6 –	17 13 –	3 4 –	19 18 –	7 1 –
TRIPLE	T9	T12	T5	T20	T10	T2	T17	T3	T19	T7
DOUBLE	D9	D12	D5	D20	D10	D2	D17	D3	D19	D7
SINGLE	S9	S12	S5	S20	S10	S2	S17	S3	S19	S7
BULL	DB	SB	–	–	–	–	–	–	–	–
SINGLE	S14	S11	S8	S16	S15	S6	S13	S4	S18	S1
DOUBLE	D14	D11	D8	D16	D15	D6	D13	D4	D18	D1
TRIPLE	T14	T11	T8	T16	T15	T6	T13	T4	T18	T1

Maintenant que l’on sait comment ça marche, il ne reste plus qu’à le connecter aux GPIO du microcontrôleur de son choix.

Dans ce tutoriel nous avons choisi de connecter la cible à un Raspberry Pi B+ mais il est tout à fait possible de le faire avec un Arduino, un ESP8226 ou encore un autre type de Pi. La seule contrainte est qu’il faut au moins 17 GPIO, il faudra donc augmenter le nombre de GPIO à l’aide d’un MCP23017-E/SP 16 I/O Expander.

Il faudra aussi que soit installé sur le device une sentinelle constellation.

Les nappes étant en plastique on ne peut venir souder dessus, on choisit donc de venir souder les fils sur le circuit imprimé directement, ensuite on peut remonter le tout. Et pour tester on les relies au Pi à l’aide d’une plaque de test (BreadBoard).

On peut maintenant déployer un package sur le pi pour connecter notre cible a constellation. Sur Le raspberry Pi, le plus simple est de faire un package python en utilisant la librairie GPIO.

Cette petite fonction va permettre de transformer un couple de GPIOs (entré, sortie), en un message pour constellation contenant une zone de la cible.

def dartTouch(pinin,pinout):
    outputDictionary = {}
    outputDictionary[PIN_TRIPPLE_1] = [3,1]
    outputDictionary[PIN_DOUBLE_1] = [2,1]
    outputDictionary[PIN_SINGLE_1] = [1,1]
    outputDictionary[PIN_BULL] = [0,2]
    outputDictionary[PIN_SINGLE_0] = [1,0]
    outputDictionary[PIN_DOUBLE_0] = [2,0]
    outputDictionary[PIN_TRIPPLE_0] = [3,0]

    inputDictionary = {}
    inputDictionary[PIN_9_14_B] = [9,14,50]
    inputDictionary[PIN_20_16_1] = [20,16,1]
    inputDictionary[PIN_12_11_B] = [12,11,25]
    inputDictionary[PIN_5_8_2] = [5,8,2]
    inputDictionary[PIN_6_2_3] = [6,2,3]
    inputDictionary[PIN_10_15_4] = [10,15,4]
    inputDictionary[PIN_13_17_5] = [13,17,5]
    inputDictionary[PIN_4_3_6] = [4,3,6]
    inputDictionary[PIN_18_19_7] = [18,19,7]
    inputDictionary[PIN_1_7_8] = [1,7,8]


    isButton = False
    value = inputDictionary[pinin][outputDictionary[pinout][1]]
    multiple = outputDictionary[pinout][0]
    if(multiple == 0):
        isButton = True
        multiple = 1
        if(value == 50):
            multiple = 2
            value = 25
            isButton = False
        if(value == 25):
            multiple = 1
            isButton = False
    if isButton :
       Constellation.SendMessage("DartManager", "ButtonPressed",[ value ])
    else:
       Constellation.SendMessage("DartManager", "onDartTargetTouch",[ multiple, value ])
    time.sleep(0.8)

Il ne reste plus qu’à alimenter les pins de sorties une à une et de lire l’état des pins en entrée.

while True:
  for pinout in outs:
    GPIO.output(pinout,GPIO.HIGH)
    for pinin in ins:
      if(GPIO.input(pinin)):
        dartTouch(pinin,pinout)
    GPIO.output(pinout,GPIO.LOW)

Une fois notre prototype avec la BreadBoard testé et approuvé nous avons pus réaliser un deuxième prototype sur lequel nous avons juste à venir brancher les pins de notre pi et de notre cible.

Ce prototype moins encombrant, apporte également plus de robustesse à notre jeu dans l’optique d’une utilisation plus fréquente.

Constellation

Afin de pouvoir envoyer l’information qu’une fléchette a touché la cible, de pouvoir traiter l’information pour par exemple savoir si l’utilisateur en a déjà lancé trois et ainsi que cette dernière ne compte pas, puis afficher cette information sur les différentes interfaces graphiques, nous devions créer un bus de données.

Pour cela, nous avons utilisé le principe des “StateObject” et ”MessageCallBack” de Constellation afin de communiquer entre chacune des différentes parties.

Deux packages Constellation ont donc été créé, l’un en Python, pour la détection des fléchettes et l’autre en C# pour la gestion de parties.

Ainsi lorsque qu’une fléchette touche la cible, le package en Python va envoyer cette information au package C# en appelant la méthode “onDartTargetTouch”,

Constellation.SendMessage("DartManager", "onDartTargetTouch",[ multiple, value ])

qui va, après avoir effectué les modifications engendrées par ce coup sur la partie, mettre à jour le StateObject ‘’DartGame’’ afin que, l’UI qui s’y est abonné, soit informé.

[MessageCallback]
void onDartTargetTouch(short multiple,short value)
{
   PackageHost.WriteInfo(multiple + " "+ value);
   if(game.applyShoot(new Shoot(multiple, value), this)){}
   update();
}

private void update()
{
   PackageHost.PushStateObject("DartGame", game);
}

Le StateObject “DartGame” représentant la partie actuelle (joueurs, tours, tirs, etc..) sous forme d’un objet JSON.

Le but étant, une fois les paquets installés sur chacune des machines respectives (“sentinelle” pour Constellation), de pouvoir tout contrôler depuis l’UI. Des MessageCallBack sont donc mis à la disposition de cette dernière, représentant ainsi l’ensemble des fonctions nécessaires à la gestion d’une partie.

User Experience

Le gros point noir de notre cible, comme nous l’avons décrit en introduction, était l’interaction avec les utilisateurs et comme vous pouvez vous en douter après les modifications que nous avons apportés à notre cible l’afficheur de score d’origine n’est plus fonctionnel. Pour le remplacer nous avons donc réalisé un Dashboard sous la forme d’une application web.

Le Dashboard

Le Dashboard comme nous l’avons évoqué ci-dessus est une application qui nous permet d’afficher les scores provenant de notre Constellation simplement en s’abonnant au StateObject du manager de jeu. L’interface de ce Dashboard a été réalisé avec AngularJS et Angular Material pour le design. En effet en nous abonnant à un StateObject via Constellation, le Dashboard est notifié de chaque modification apportées à la partie de fléchette en cours et de modifier l’affichage dynamiquement grâce à l’objet JSON fournis par Constellation tout cela en simplement quelques lignes de codes :

constellation.registerStateObjectLink("*", "*", "DartGame", "*", function (so) {
    $scope.$apply(function() {
       $scope.constelationGame = so.Value;
    });           
});

La connection du Dahboard à Constellation permet également d’exposer des méthodes afin de déclencher des effets sonores sur certains lancers afin de dynamiser la partie.

constellation.subscribeMessages("DartsDashboard");
constellation.registerMessageCallback("Triple", function (msg) {
    var audio = new Audio('sounds/Triple.wav');
    audio.play();
});
                
constellation.registerMessageCallback("Double", function (msg) {
    var audio = new Audio('sounds/Double.wav');
    audio.play();
});

Pour le design, Angular Material nous a permis de développer rapidement et simplement une interface esthétique.

L’application mobile

Toujours dans le but d’améliorer les fonctionnalités offertes par notre jeu customisé, une application mobile accompagne notre nouvel objet connecté pour y ajouter une dimension sociale ! Baptisé My Dart Compagnon, elle se destine aux joueurs les plus passionnés.

L’application est réalisée avec Ionic, un Framework open source qui permet de développer des applications mobiles hybrides rapidement et facilement. Il s’appuie sur AngularJS pour la partie application web du framework et sur Cordova pour la partie construction des applications natives. On peut donc très facilement se connecter à Constellation via le SDK JavaScript. Ionic framework permet de développer une seule application et de la déployer sur tous les supports, web ou mobile, que ce soit Android, iOS ou bien Windows Mobile.

De plus, l’application intègre les services Firebase, la plateforme d’outils mobile de Google qui permet d’implémenter un espace de stockage synchronisé et personnel pour l’utilisateur en toute simplicité, en mode cloud. Cet espace peut être accessible par d’autres clients, comme par exemple le Dashboard.

En utilisant l’authentification Facebook, l’application permet de voir ses amis qui l’utilisent également et de les inviter à jouer. Au début de chaque partie, le joueur peut charger son profil sur le Dashboard présenté ci-dessus en flashant un QR Code. Cela lui permet de suivre son score personnel durant la partie sur son smartphone, de consulter l’historique de ses parties disputées et ses statistiques personnelles. Les joueurs les plus compétiteurs chercheront eux à débloquer l’intégralité des succès : des récompenses débloquées lors de la réalisation de certaines actions ou performances.

The post Jeu de fléchettes connecté à Constellation appeared first on Constellation.

Installer Constellation sur Linux

Sebastien Warin — Wed, 03 May 2017 22:59:59 +0000

Dans cet article nous allons découvrir comment installer Constellation sur un système Linux/Debian et ses dérivés (Raspbian, Ubuntu, etc..).

Les étapes sont conceptuellement les mêmes que pour une installation sur Windows.

Prérequis

Le bootstrapper du Web Platform Installer pour Linux utilise l’outil APT pour installer automatiquement les dépendances de Constellation à savoir :

Python 2.7 et ses outils de développement (python-dev)
Mono 3.12 au minimum pour le serveur (Mono 3.10 pour la sentinelle)
Supervisor
Whiptail

Si vous êtes sur une autre distribution que Debian (ou ses dérivés) et que vous ne disposez pas de l’outil APT, vous devrez installer ces packages manuellement.

Dans cet article nous avons créé une machine virtuelle x64 et installé le système Linux Debian 8.2 en “net-install” (à télécharger ici).

Notez que la procédure est exactement la même pour un Raspberry Pi (sous Raspbian). A ce sujet, une page spécifique au Raspberry Pi et Constellation est disponible ici.

Lors de l’installation du système Debian, nous avons installé les utilitaires de base ainsi que le serveur SSH, ni plus ni moins :

A la fin de l’installation, nous pouvons nous connecter à cette machine Linux fraîchement installée depuis un client SSH comme Putty :

Pour finir, il est fortement recommandé de mettre à jour les sources APT avant de commencer l’installation de Constellation en lançant la commande suivante (en root) :

apt-get update

N’oubliez pas, par défaut sur Debian 8, “sudo” n’est pas installé. Ainsi pour lancer des commandes en root :

soit vous vous connectez en SSH directement avec le login root
soit vous lancez la commande “su” pour ouvrir la session root depuis votre session courante
soit vous installez et configurez “sudo”

Voilà, notre machine Linux est prête à recevoir Constellation !

Lancer le Web Platform Installer Linux

Pour télécharger et démarrer Web Platform Installer, rien de plus simple ! Lancez simplement la commande suivante :

wget -O install.sh https://developer.myconstellation.io/download/installers/install-linux.sh && chmod +x install.sh && ./install.sh

Le Web Platform Installer (WPI) se chargera lui même de se lancer en root en utilisant “sudo” ou “su” si la première commande n’est pas disponible.

Ainsi si le WPI est lancé depuis un autre utilisateur, vous serez amené à saisir le mot de passe du compte “root” pour l’autoriser à se lancer :

Installer la plateforme

Etape 1 : installation des prérequis

Comme décrit plus haut, le WPI va installer via APT les dépendances nécessaires pour Constellation (Python-Dev, Mono et Supervisor).

Comme il s’agit d’un système fraîchement installé, nous laissons le WPI installer l’ensemble des prérequis.

Etape 2 : sélectionnez les composants Constellation à installer

Le WPI vous permet d’installer :

Le Serveur Constellation (avec ou sans la Console)
La Console Constellation
La Sentinel Service

Dans notre cas nous allons commencer par installer le serveur avec la console. Nous sélectionnons donc la première option :

Etape 3 : acceptez la licence d’utilisation

Vous retrouverez le détail des licences Constellation sur cette page. Pour résumer, Constellation est gratuit pour un usage personnel ou éducatif sans aucun but lucratif et soumis à l’acquisition d’une licence pour un usage professionnel ou entreprise.

Etape 4 : identification

Vous devez dans cette étape renseigner votre compte myConstellation.io afin de pouvoir télécharger les composants Constellation et accéder à vos licences :

Etape 5 : configuration du serveur Constellation

Entrons désormais dans les étapes de configuration de chacun des composants à installer en commençant par le serveur Constellation.

Etape 5.1 : répertoire d’installation

Vous devez choisir le répertoire d’installation du serveur Constellation :

Etape 5.2 : sélection de la licence

Vous devez ici sélectionner une licence pour l’utilisation du serveur. Vous obtiendrez l’ensemble des licences associées à votre compte avec la possibilité de créer des licences gratuites pour un usage personnel (plus d’information ici).

Etape 5.3 : choix du répertoire des packages

Dans cette étape vous devez définir le répertoire pour votre catalogue de packages de votre Constellation.

Par défaut, il s’agit du sous-dossier “Packages” de votre répertoire d’installation :

Etape 5.4 : choix du port d’écoute du serveur

Le serveur Constellation utilise le protocole HTTP/s pour exposer ses différents hubs et APIs. Pour cela vous avez besoin de choisir le port d’écoute.

Par défaut, le serveur Constellation écoutera en HTTP sur le port 8088.

A noter que vous pouvez déclarer dans la configuration du serveur Constellation sur plusieurs ports HTTP et/ou HTTPS ou même définir un chemin HTTP personnalisé. Il est d’ailleurs conseillé d’activer le protocole HTTPS si vous souhaitez exposer votre serveur Constellation sur Internet. Vous retrouverez plusieurs articles sur la configuration avancée du serveur dans la rubrique Constellation Server.

Etape 5.5 : choix des clés d’accès

Pour se connecter à Constellation vous avez besoin de créer des clés d’accès (les “Access Keys”). Dans le cas d’une nouvelle installation, l’assistant vous proposera de créer deux clés :

Une clé “Standard” (accès de base) que vous utiliserez pour connecter vos sentinelles et packages
Une clé “Administrator” qui dispose des droits d’accès au hub de contrôle (pour le pilotage de la Constellation) et à l’API de Management (pour la configuration du serveur)

Une clé d’accès est une chaine de caractère. Il est conseillé de choisir des clés d’accès assez longues (> 16 caractères) et compliquées.

Pour simplifier leurs mémorisations et générations, Constellation propose d’utiliser un couple login/password pour créer des clés d’accès. Pour cela, on utilise le hash SHA1.

Exemple : pour le login “Admin” et le mot de passe “Password”, la clé d’accès sera “d882b8721a224d38ebb54559e6b54e5df3a1bc6d” (soit SHA1(“AdminPassword”)). Notez bien que la casse est importante !

C’est pourquoi le WPI vous proposera soit de spécifier directement vos AccessKeys ou soit d’utiliser un couple login/password.

Ici sélectionnons la deuxième option :

Pour la clé “Standard” utilisons le couple “demo/demo” :

Et pour la clé “Administrator”, utilisons le couple “admin/password” :

Pour finir, vous pouvez ajouter le droit de débogage sur la clé “Administrator”. Cela nous permettra de tester des packages connectés à votre Constellation depuis le SDK sous Visual Studio.

Etape 6 : installation et configuration de la Console Constellation

Une fois le serveur installé, le WPI vous proposera d’installer et configurer automatiquement la Console Constellation :

Vous devez simplement spécifier le répertorie d’installation, par défaut dans /opt :

Vous pouvez aussi indiquer si vous souhaitez restreindre l’accès la console à “localhost” (ce qui n’aurait pas de sens dans notre cas étant donné que notre système Linux ne dispose pas de navigateur internet localement) :

Etape 7 : Validation de l’installation

Et voilà, le serveur Constellation ainsi que la Console sont installés sur votre système Linux.

Ouvrez un navigateur Internet et rendez-vous sur l’adresse IP ou DNS de votre système Linux sur le port spécifié lors de l’installation (par défaut 8088). Vous devriez atterrir sur une page du serveur Constellation vous indiquant le n° de la version du serveur, dans notre exemple 1.8.2.17118 :

Comme le serveur Constellation héberge la Console, vous avez un lien “Open Constellation Console” sur cette page vous permettant d’accéder directement à la Console :

Utilisez le couple login/password “Administrator” défini lors de l’installation pour vous connecter, dans notre exemple “admin/password” :

Bravo, votre serveur Constellation est opérationnel !

Next steps

Prêt pour développer avec Constellation ?

The post Installer Constellation sur Linux appeared first on Constellation.

Créez votre premier package Constellation en Python

Sebastien Warin — Fri, 01 Apr 2016 08:28:19 +0000

Vous pouvez développer des packages Constellation avec le langage Python. Sur vos sentinelles Windows comme sur vos sentinelles Linux vous pourrez profiter des différentes libraires et de l’écosystème Python connectés dans Constellation.

Découvrons dans cet article comment créer et déployer votre premier package Constellation en Python.

Prérequis

Tout d’abord, que vous soyez sur Windows ou Linux, il vous faudra un interpréteur Python 2 ou Python 3 et une ou deux libraires indispensables pour Constellation.

Notez que ces prérequis sont automatiquement installés sur Linux avec le Web Platform Installer.

Installer Python sur Windows

Téléchargez Python pour Windows (en version 2.x ou 3.x) puis lancez l’installation en choisissant une installation pour tous les utilisateurs :

Sélectionnez le composant “PIP” ( le gestionnaire de package Python) et ajoutez “Python.exe” dans les “Paths” Windows :

Une fois l’installation terminée, lancez une invite de commande (cmd.exe) et assurez-vous que la commande “python” fonctionne :

Toujours dans une invite de commande Windows, installez via PIP les librairies “pyzmq” (et “enum34” si vous êtes en Python 2.x) grâce aux commandes suivantes :

pip install pyzmq
pip install enum34

Si vous êtes sur Python 3.x, vous n’avez pas besoin du module “enum34”, seulement “pyzmq”.

Et voilà, votre environnement Windows est prêt !

Installer Python sur Linux

Sur un système Debian ou similaire (Raspbian, Ubuntu, etc …), vous n’avez qu’à installer (et enregistrer dans votre Constellation) une sentinelle Constellation.

Le Web Platform Installer vous proposera d’installer tous les prérequis nécessaires à savoir Python et les librairies “pyZmq” et “enum34” (si Python 2.x) via PIP.

Autrement, pour installer manuellement ces prérequis, vous pouvez utiliser les mêmes commandes que sur Windows :

sudo easy_install pip
sudo pip install pyzmq
sudo pip install enum34

Encore une fois, la libraire “enum34” est seulement requise sur Python 2.x.

Enfin si vous utilisez un Raspberry Pi, vous pouvez également consulter cet article en particulier.

Et voilà, votre environnement Linux est prêt !

Développer un package Python en ligne de commande

Vous pouvez soit utiliser le SDK Constellation basé sur Visual Studio pour créer, tester et déployer des packages Constellation (.NET ou Python) ou bien, utiliser l’outil en ligne de commande nommé « Constellation Package Tools CLI ».

Le développement sous Visual Studio est abordé ci-dessous. Pour l’outil en ligne de commande, rendez-vous sur la page : Créer, tester et déployer des packages Python en ligne de commande

Développer un package Python avec Visual Studio

Après avoir installé les prérequis et le SDK Constellation, lancez Visual Studio et créez un nouveau package Constellation de type “Python” :

Une fois créé le projet Visual Studio a la structure suivante :

Vous retrouverez une structure classique pour un package Constellation :

App.config : le fichier de configuration local pour définir les valeurs locales de vos settings (lire ici) ainsi que les scripts Python à démarrer
PackageInfo.xml : le manifeste de votre package
packages.config : le fichier des packages Nuget de votre projet (réservé à Nuget)
Program.cs : le point d’entrée (C#) de votre package qui se chargera de lancer le “Python Proxy” (le pont entre vos scripts Python et Constellation)
Le répertoire “Scripts” (qui contient vos scripts Python)
- Constellation.py : le proxy Python Constellation (la librairie Python) : ne pas modifier !
- Demo.py : un script Python d’exemple

Configurer les scripts à démarrer

Vous pouvez ajouter autant de scripts Python dans le dossier “Scripts” comme vous le souhaitez. Pour cela, cliquez-droit sur ce répertoire et sélectionnez « Ajouter un nouvel élément ».

Dans la catégorie « Constellation » sélectionnez « Constellation Python Script » :

Chaque script sera démarré dans un processus dédié et connecté à Constellation.

Attention : si vous rajoutez des scripts Python dans ce dossier, il faut obligatoirement les inclure dans le package en sélectionnant “Copy if newer” pour la propriété “Copy to Output directory”. Cette propriété est automatiquement définie à cette valeur si vous avez créé votre fichier Python en sélectionnant l’élément « Constellation Python Script » comme expliqué ci-dessus.

Dans le fichier « App.config » vous devez déclarer les fichiers Python à démarrer. Les scripts Python créé en sélectionnant l’élément « Constellation Python Script » sont automatiquement ajoutés dans ce fichier lors de la création. Si vous renommez ou supprimer vos scripts, n’oubliez pas de mettre à jour ce fichier.