Tag Raspberry Pi - Constellation

FriendLeaf : la serre connectée grâce à Constellation

Sebastien Warin — Tue, 17 Jul 2018 09:40:50 +0000

Plus besoin de disposer d’un espace extérieur pour faire pousser vos propres herbes aromatiques, salades et fleurs. Grâce à la serre connectée FriendLeaf, vous pouvez faire pousser plusieurs plantes et vous en occuper facilement.

Projet réalisé par Théo DELOOSE, Clara BOMY, Clément NOUGÉ, Mathieu GABRIEL, Marine DAEL et Thaï-Son DANG.

Introduction

Nous sommes six étudiants en troisième année à l’ISEN Lille. Dans le cadre de notre projet de fin d’année, nous avons conçu une serre connectée dédiée à un usage en intérieur. Celle-ci est équipée d’un système d’éclairage intelligent, d’une pompe d’arrosage automatique et d’un brumisateur intégré afin de garantir la bonne croissance des plantes, rassemblant les conditions nécessaires à leur développement. Pour une plus grande facilité d’utilisation, notre serre est associée à une application mobile simple et ludique permettant de suivre en temps réel les données de l’environnement de la serre et de contrôler celle-ci à distance.

En réalisant ce projet, notre but était de proposer une solution de serre connectée à un prix raisonnable et possédant une interface attrayante pour améliorer l’expérience de l’utilisateur.

De plus nous voulions que la serre puisse être intégrée dans différents systèmes facilement pour que l’utilisateur puisse utiliser les données à sa guise.

Fonctionnement général

Nous avons pensé FriendLeaf comme un système de monitoring et de pilotage. Il propose en effet de gérer automatiquement l’arrosage, l’humidité et la luminosité de la serre, ou bien de les activer manuellement à notre guise. Il synchronise les données récupérées par les différents capteurs grâce à la plateforme Constellation et active, par le biais d’un relais, les actionneurs. Enfin, FriendLeaf alerte l’utilisateur lorsque le réservoir d’eau est vide. Tout est synchronisé en temps réel comme par magie grâce à Constellation.

Nous avons donc ajouté dans la serre les capteurs permettant de relever les informations sur l’humidité de l’air et du sol, sur la température et sur la luminosité. L’équipement installé comporte aussi une guirlande lumineuse ayant pour but d’éclairer et d’afficher les alertes, une pompe pour le système d’arrosage et un brumisateur permettant d’humidifier l’air.

Matériel utilisé

Pour réaliser notre projet, nous nous sommes servis des composants suivants :

Pour la Serre :

Serre SOCKER Ikea (12,99€), Ikea
Bac pour le terreau (1,50€), Jardinerie
Carte Raspberry Pi 3B (40,80€), Amazon
Relais 4 canaux supportant jusqu’à 5A et 250V (AC) et 30V (DC) (9,99€), Amazon
Câbles de connexion
Boîte de dérivation

Pour les capteurs :

Humidité et température air : DHT11 (1,31€), Amazon
Luminosité : TSL2561 (6,95€), Gotronic
Humidité sol : GT110 (2,40€), Gotronic
Niveau d’eau : Gravity SEN0205 (10,50€), Gotronic

Pour le brumisateur :

Un émetteur à ultrasons (9,89€), Amazon
Une alimentation pour le brumisateur (24V DC, 1A) (25€), Derotronic, Lille
Un bol

Pour le système d’arrosage :

Une pompe à eau (5,48€), Amazon
Une alimentation 12V 600mA (12€), Derotronic, Lille
Un jerrican (environ 10€)
Un tuyau (ø7mm -ø10mm), Diall

Pour l’éclairage :

2m de guirlandes lumineuses (1m LED et 1m incandescent), Blachère
Une alimentation pour fil lumière, Blachère
Colliers de serrage

Conception de la serre

Étape 1 : Préparation de la serre

Dans la serre, nous avons disposé les capteurs, le pot et un bol pour le brumisateur. Nous avons également percé des trous pour pouvoir faire passer tous les capteurs et le tuyau d’arrosage.

Pour ce qui est de la guirlande lumineuse, il nous a fallu percer quelques trous supplémentaires dans les montants de la serre pour y glisser les colliers de serrage.

Étape 2 : Branchement du relais

Afin de pouvoir contrôler les actionneurs, nous avons branché le relais quatre canaux à une carte Raspberry Pi.

Celui-ci est analogue à un interrupteur. Pour chaque canal, une alimentation est nécessaire et chacun d’entre eux peut être piloté individuellement grâces aux différents pins dont dispose le relais. Il faut également prévoir une masse que l’on branche sur le pin “Gnd” du relais.

Par défaut, lorsque les pins d’entrée ne sont pas alimentés, les canaux du relais délivrent la tension d’alimentation correspondante sur la sortie NC (“Normally Closed”) ou sur la sortie NO (“Normally Open”) dans le cas contraire.

Etape 3 : Éclairage de la serre

Pour l’éclairage de notre serre, nous avons percé des trous dans la structure et fixé la guirlande avec des colliers de serrage. Celle-ci doit être alimentée par une tension de 230V (tension secteur) et est composée d’un mètre de LEDs rouge et d’un mètre incandescent jaune.

Elle est connectée au relais par la phase et le neutre, chacun branchés sur un canal différent, afin d’isoler totalement la guirlande du secteur et ainsi éviter tout problème avec le reste des composants.

Etape 4 : Installation du brumisateur

Pour augmenter l’humidité de l’air dans la serre, nous avons installé un brumisateur fonctionnant par émissions d’ultrasons. Il nécessite une alimentation de 24V/1A maximum. On le relie ensuite au relais. La masse est directement connectée à l’adaptateur secteur par le biais d’un domino.

Etape 5 : Installation du système d’arrosage

En ce qui concerne l’arrosage, nous disposons d’une pompe submersible qui nécessite une alimentation de 12V et 400mA. Elle est branchée en sortie à un tuyau percé pour un arrosage homogène. Nous la connectons ensuite à un des canaux du relais.

Pour le réservoir, nous avons récupéré un bidon de vinaigre de 5L sur lequel nous avons fait un trou pour le capteur de niveau d’eau et une ouverture pour le remplir et y faire passer la pompe.

Pour résumer…

Étape 6 : Mise en place des capteurs et paramétrage de la carte Arduino

Nous installons à présent les capteurs d’humidité/température de l’air, d’humidité du sol, de de luminosité et de niveau d’eau. Nous branchons tous ces capteurs aux pins de la Raspberry ou de l’Arduino en faisant attention au fait que :

Les capteurs d’humidité du sol et de niveau d’eau se branchent sur du 5V.
Les capteurs d’humidité/température de l’air et de luminosité sont alimentés en 3,3V.

Étape 6.1 : Capteur d’humidité et de température de l’air

Le capteur d’humidité et de température de l’air fournissant des données numériques, nous le relions directement à notre Raspberry Pi comme montré sur le schéma ci-dessous :

Étape 6.2 : Capteurs de luminosité, d’humidité du sol et de niveau d’eau

Ces capteurs fournissant des données analogiques, nous les avons branchés à une carte Arduino nano qui permet de lire ces données, contrairement à la Raspberry. Elle est reliée directement par USB à la Raspberry Pi comme montré ci-après :

Étape 6.3 : Programmation de la carte Arduino

Dans l’IDE Arduino, nous avons donc commencé par programmer la carte.

Nous ajoutons tout d’abord les librairies d’Adafruit pour pouvoir initialiser le capteur de luminosité et régler le temps d’intégration des données. Dans le gestionnaire de bibliothèque (menu Croquis > Inclure une bibliothèque), nous avons installé les librairies suivantes :

Adafruit Unified Sensor
Adafruit TSL2561

Au démarrage, dans la méthode “setup()”, nous configurons les pins utilisés. Nous décidons d’utiliser les pins analogiques A0 et A1, respectivement pour le capteur d’humidité du sol et du niveau d’eau et les pins A4 et A5 pour le capteur de luminosité :

void setup(void) 
{
  Serial.begin(9600);
 
  /*Réglage du capteur de luminosité*/
  if(!tsl.begin()) //Initialisation du capteur
  {
    //S'il y a un problème pour détecter le capteur, vérifier votre connexion
    Serial.print("Ooops, pas de capteur détecté... Vérifier votre connexion!");
    while(1);
  }
  
    //Configuration du gain du capteur et du temps d'intégration
    tsl.enableAutoRange(true);          
    tsl.setIntegrationTime(TSL2561_INTEGRATIONTIME_13MS);    
 
}

Dans la méthode “loop()”, nous recueillons ensuite les valeurs des capteurs et les faisons afficher sur le Monitor Série en utilisant les commandes analogRead() et Serial.print() :

void loop(void) 
{  
  /*Pour recevoir une nouvelle donnée par le capteur de luminosité*/ 
  sensors_event_t event;
  tsl.getEvent(&event);
 
  //Lecture des pins analogiques pour les données des capteurs d'humidité du sol et de niveau d'eau
  Hum_value = analogRead(A0);
  Liquid_value=analogRead(A1);
 
  //Affichage des valeurs sur le Moniteur série
  Serial.print(event.light,0);
  Serial.print(',');
  Serial.print(map(Hum_value,0,1024,0,100)); //Le capteur d'humidité renvoie une valeur en pourcentage 
  Serial.print(',');
  Serial.println(map(Liquid_value,0,512,0,1)); //Le capteur de niveau d'eau retourne la valeur 1 quand il est en contact avec l'eau, 0 sinon
  delay(5000); //Retard de 5s pour éviter de surcharger le buffer de la Raspberry 
}

Nous récupèrerons ensuite les données des différents capteurs à l’aide de la carte Raspberry Pi.

La programmation vers Constellation

La programmation vers Constellation est divisée en deux packages : le premier correspond à la récupération des données des capteurs et à l’activation des actionneurs, le second a été créé pour gérer le stockage des données en vue de créer des graphiques sur notre application.

Etape 1 : Package relatif aux capteurs et actionneurs

Etape 1.1 : Acquisition des données des capteurs

Pour récupérer les données des différents capteurs cités précédemment, nous avons utilisé la librairie “Adafruit_DHT” pour Raspberry Pi et la librairie “serial” qui permet de faire le lien entre l’Arduino-Nano et la Raspberry Pi. Ces valeurs vont nous permettre de décider s’il faut activer ou non les actionneurs tels que la pompe, le brumisateur ou les LED.

La fonction ci-après permet de récupérer les valeurs des différents capteurs.

def getCapteur():
    humiditeAir, temperature = Adafruit_DHT.read_retry(11,4)
    lux, humiditeSol, eau = ser.readline()[:-2].split(",")

Nous avons ensuite créé un State Object rassemblant les valeurs d’humidité du sol, d’humidité de l’air, de température et de luminosité ambiante pour pouvoir les publier sur notre Constellation.

Constellation.PushStateObject("Capteurs", {"HumiditeSol": int(self.humiditeSol), "HumiditeAir": int(self.humiditeAir), "Temperature": int(self.temperature), "Luminosite": int(self.lux)}, "CapteursInfos")

Etape 1.2 : Activation et désactivation des différents actionneurs (brumisateur, guirlande lumineuse et pompe à eau)

Comme mentionné précédemment, les actionneurs sont reliés à la Raspberry Pi via un relais quatre canaux. Cela simplifie grandement la programmation : il nous suffit simplement de gérer l’ouverture et la fermeture des relais.

Nous avons donc fait en sorte que chaque actionneur soit associé à son relais grâce à la librairie GPIO de la Raspberry Pi. Ainsi, le code diffère seulement au niveau des numéros des pins utilisés par les actionneurs.

Voici un exemple du code de l’activation et de la désactivation de notre pompe :

GPIO.setmode(GPIO.BOARD)
GPIO.setup(12,GPIO.OUT)
GPIO.output(12,0)

Le pin 12 de la Raspberry est celui relié au relais contrôlant la pompe.

Etape 1.3 : Automatisation des actionneurs

Pour réaliser la fonction d’automatisation, nous nous sommes tout d’abord renseignés sur les conditions propices à la bonne croissance des plantes au niveau de l’humidité du sol et de l’air, de la luminosité et de la température de l’air.

Pour le brumisateur, nous avons choisi de l’activer si l’humidité est inférieure à 35% et de le désactiver si l’humidité remonte au dessus de 37%.

if humiditeAir > 37 and brumisateur:
    DesactiverBrumisateur()
elif humiditeAir < 35 and not brumisateur:
    ActiverBrumisateur()
    time.sleep(1)

Pour la pompe, le fonctionnement est différent. Puisque la diffusion de l’eau dans la terre est plus lente, nous activons la pompe pendant 5s avant de la désactiver pendant 30s pour laisser le temps au capteur de ressentir les changements.

if humiditeSol < 30 and not pompe:
    if self.ticks == 0:
            if self.next_water == 0:
                    ActiverPompe()
            self.next_water = 15
        else:
                    self.next_water -= 1
        elif humiditeSol > 30:
                    self.next_water = 0
    elif pompe:
            self.ticks += 1
               if self.ticks >= 3:
                    DesactiverPompe()
                       self.ticks = 0
time.sleep(1)

Ces différentes fonctions sont exécutées dans des threads séparés pour ne pas que le code soit bloquant.

Maintenant, il ne reste plus qu’à sécuriser notre système d’arrosage via le capteur de niveau d’eau. Connecté à la carte Arduino nano, ce capteur va nous renvoyer 1 s’il y a de l’eau dans le réservoir, 0 sinon.

Les données du capteur de niveau d’eau nous permettent d’arrêter le système d’arrosage lorsque le réservoir est presque vide et d’informer l’utilisateur via un PushBullet et l’allumage des LEDs qu’il faut remplir le réservoir.

Constellation.SendMessage("PushBullet", "PushNote", [ "FriendLead", "Le reservoir d'eau est vide"], Constellation.MessageScope.package)

Étape 2 : Package relatif au stockage des données

Afin d’historiser les valeurs des capteurs stockées dans un des State Objects du premier package, nous en avons créé un autre que l’on a déployé sur le même serveur que Constellation.

Ce package génère une base de données dans un fichier .csv qui est mis à jour toutes les minutes avec les nouvelles données.

Chaque ligne contient la date, l’heure, l’humidité du sol, l’humidité de l’air, la température et la luminosité.

@Constellation.StateObjectLink(package = "FriendLeafCapteurs", name = "Capteurs")
def RecupValue(stateObject):
    humiditeSol = stateObject.Value.HumiditeSol
    humiditeAir = stateObject.Value.HumiditeAir
    temperature = stateObject.Value.Temperature

Nous avons ensuite créé un message callback qui permet de visualiser le fichier CSV dans notre Constellation.

@Constellation.MessageCallback()
def LireBDD():
'''
: return string : La base de données 
'''
    file = open('BDD.csv','r')
    lines = file.readlines()
    return lines

L’interface utilisateur : l’application mobile de monitoring et de pilotage de la serre

Étape 1 : Le noyau de l’application

Pour développer l’application mobile nous nous sommes aidés de Cordova, un Framework permettant de créer des application Android et iOS avec des technologies web.

Nous avons également utilisé jQuery et AngularJS pour faciliter l’interaction entre Javascript et HTML.

De plus, pour gérer certaines fonctionnalités comme le traitement du CSV ou l’affichage des graphiques, nous avons utilisé des librairies externes comme PapaParser et Chartist. Finalement, pour embellir le CSS, nous avons utilisé le Framework SemanticUI qui ressemble en certain points à Bootstrap.

Étape 2 : Connexion à Constellation, State Object et Messages Callback

Pour nous connecter à Constellation avec AngularJS, nous avons utilisé ces lignes de codes :

Constellation.initializeClient(url_port, sha, "FriendLeaf");

Constellation.onConnectionStateChanged(function (change) {
   //suite
});

et une ligne de ce type pour chaque State Object :

Constellation.registerStateObjectLink("*", "FriendLeafCapteurs", "Actionneurs", "*", function (so) {
    //suite
});

Quant aux messages Callback, ils sont envoyés comme suit :

Constellation.sendMessage({ Scope: 'Package', Args: ['FriendLeafCapteurs'] }, 'DesactiverBrumisateur');

Pour que l’application soit utilisable sur n’importe quelle Constellation, nous avons créé un page de configuration où l’utilisateur rentre l’adresse de sa constellation, le port, et des identifiants.

Une fois tout cela rempli, le nom d’utilisateur et le mot de passe sont hachés en SHA1 grâce à une librairie externe et la connexion à Constellation commence.

Lorsque l’application se lance pour la première fois, l’utilisateur est directement redirigé vers cette page pour entrer les informations nécessaires.

Étape 3 : Affichage des données en temps réel

Pour l’affichage des données en temps réel nous avons utilisé des images SVG car elles sont très flexibles et nous voulions réaliser des barres de progression en arc de cercle. Pour les valeurs numériques on affiche un scope AngularJS dans lequel sont stockés les valeurs des capteurs.

Le code JS :

//Stockage des valeurs des capteurs dans la variable capteur
scope.capteurs["humiditeAir"] = so.Value.HumiditeAir;
scope.$apply(); //Applications des modifications du scope

//Pour changer le remplissage de la jauge 
$("#h_air_gauge").css("stroke-dasharray",(so.Value.HumiditeAir*18)/100 + " 18 0");

SVG en HTML :

Étape 4 : Contrôler sa serre

Nous avons également prévu dans l’application de pouvoir gérer les différents actionneurs de la serre.

Pour gérer le côté automatique du package responsable des capteurs nous avons utilisés des sliders qui lorsqu’activés, vont envoyer un Message Callback comme décrit ci-dessus. On va également suivre l’évolution du State Object indiquant si l’automatisation est activée pour tel ou tel actionneur et ainsi bloqué ou non le bouton d’activation manuel. Car oui, il est également possible d’activer manuellement chaque actionneur grâce à un bouton.

Étape 5 : Les graphiques

Pour ce qui est des graphiques nous avons utilisé une librairie externe que nous avons modifié pour la rendre compatible sur mobile. Cette librairie s’appelle Chartist. Grâce à elle nous avons pu faire de superbes graphiques.

Conclusion

Voilà qui conclut les grandes étapes de la réalisation de FriendLeaf. Comme vous avez pu le voir, la serre remplit complètement son rôle. C’est un projet ludique, simple à réaliser et facilement transposable sur d’autres installations grâce aux State Objects et aux messages Callback. C’est également un bon point de départ pour prendre en main la plateforme Constellation. Nous espérons vraiment qu’il vous a plu et que vous allez réaliser votre propre serre.

Nous tenons également à remercier Léa, le jardin de Théo et les parents de Marine qui nous ont fourni quelques accessoires nécessaires à la serre.

The post FriendLeaf : la serre connectée grâce à Constellation appeared first on Constellation.

Constellation à la DevCon #4 le 26 octobre à l’école 42

Sebastien Warin — Fri, 20 Oct 2017 09:02:14 +0000

Jeudi 26 octobre 2017 se tiendra la 4ème édition de la DevCon, la conférence technique du magazine Programmez!

Le thème de cet après-midi sera 100 % Raspberry Pi & Co en production : serveur, IoT, développement, Docker.

Et à cette occasion, vous retrouverez une nouvelle fois une session dédiée à Constellation spécial Raspberry.

Au menu de cette session :

Comment déployer une Constellation sur Raspbian en une seule ligne de commande grâce au Web Platform Installer
Comment joindre des RPi v1, v2, v3 dans Constellation pour y déployer et superviser des packages (programmes) depuis une interface Web centrale
Comment développer des packages avec Visual Studio ou en ligne de commande avec le « Constellation Package Tools CLI » et les déployer automatiquement sur vos RPi
Comment vos packages Python sur RPi peuvent interagir avec vos autres systèmes et autres packages Python, C#, objets Arduino ou des ESP8266, des pages Javascript, ou autre
Comment contrôler un RPi depuis une pages Web ou une application mobile multi-plateforme avec quelques lignes !

Nous verrons également plusieurs applications concrètes déployées pour ma « smarthome » comme : S-Energy, ma solution de supervision des ressources énergique basée sur un Raspberry, S-Opener pour piloter la porte de garage depuis un Raspberry, capteurs luminosité, gestion des volets, etc…

Quand ? 26 octobre à partir de 13h30

Où : à l’école 42 (Paris)

Informations & inscriptions : https://www.programmez.com/content/devcon-4-100-raspberry-pi-co

The post Constellation à la DevCon #4 le 26 octobre à l’école 42 appeared first on 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.

Ajouter des sentinelles dans votre Constellation

Sebastien Warin — Wed, 30 Mar 2016 15:26:53 +0000

Les sentinelles sont des agents exécutés sur des systèmes Windows ou Linux qui, connectés à votre Constellation, permettent de déployer des packages Constellation.

En suivant le guide d’installation vous avez pu installer une sentinelle Service ou UI sur la même machine que le serveur Constellation.

Voyons maintenant comment installer des sentinelles sur vos autres machines (laptops, desktop, serveurs, Raspberry, etc..).

Prérequis

Il existe deux types de sentinelle :

La “Sentinel Service” : il s’agit d’un service compatible Windows et Linux qui tourne en arrière plan et permet de déployer des packages Constellation sans interface graphique.
La “Sentinel UI” : il s’agit d’une application Windows s’exécutant au sein d’une session Windows et permettant de déployer des packages Constellation avec interface graphique (dit Package UI) ou encore des packages ayant besoin d’interagir avec la session de l’utilisateur.

Les prérequis pour installer une sentinelle sont :

Un système Windows avec le .NET Framework 4.0 installé (soit au minimum un Windows XP SP3 ou un Windows 2003 SP2)
Un système Linux avec Mono 3.10 au minimum

Note : la sentinelle UI n’est disponible que pour Windows.

Installation d’une sentinelle sur un système Windows

Les installeurs pour la sentinelle Service et UI sont similaires, la procédure d’installation est donc identique.

Note : vous pouvez installer sur la même machine une sentinelle UI et une sentinelle Service.

Pour cela, vous pouvez soit télécharger le programme d’installation spécifique à la Sentinelle UI et/ou Service ou, pour faire plus simple, utiliser le “Web Platform Installer” pour installer et mettre à jour les dernières versions des composants Constellation.

Etape 1 : lancez le “Web Platform Installer

Constellation Web Platform Installer » Article
Constellation-Web-Platform-Installer-1.9.735.exe
Version: 1.9.735

1.2 MiB
2137 Downloads
Détails

Etape 2 : sélection des composants

Commencez par vous identifier avec votre compte Constellation et acceptez la licence d’utilisation avant de pouvoir sélectionner les composants à installer :

Dans le cas ci-dessus, nous avons déjà installé la dernière version du SDK Constellation comme vous pouvez le constater !

Dans ce guide nous allons installer les deux sentinelles (UI et Service) que nous connecterons à notre Constellation précédemment installée sur une autre machine.

Etape 3 : type d’installation des sentinelles

Vous avez ensuite le choix entre :

Installer la sentinelle et l’enregistrer dans votre Constellation en utilisant l’API de Management (il vous faudra connaitre une AccessKey qui a les droits de management pour procéder à l’enregistrement).
Installer la sentinelle seulement

Bien entendu pour automatiser le processus, choisissons la première option :

Notez que si vous souhaitez ajouter une sentinelle sur un système sur lequel un serveur Constellation est installé, l’assistant vous proposera d’installer et d’enregistrer automatiquement votre sentinelle sur le serveur local.

Etape 4 : sélection du serveur Constellation à joindre

Vous devez indiquer l’URI de votre serveur Constellation ainsi que la clé d’accès avec les droits d’administration pour enregistrer vos sentinelles.

Dans cet exemple le serveur Constellation est accessible sur l’URL “http://pc-seb.ajsinfo.loc:8088/” avec le couple “admin/password” (cliquez sur le bouton “Use Password” pour générer l’AccessKey à partir de ce couple) :

Etape 5 : choix de la clé d’accès pour la sentinelle

Vous aurez ensuite à choisir parmi les clé d’accès configurées sur votre serveur, laquelle doit être utilisée pour la connexion de vos sentinelles :

Etape 6 : installation

Il ne vous reste plus qu’à confirmer l’installation :

L’installeur téléchargera et installera les composants puis réalisera l’enregistrement vos deux nouvelles sentinelles sur votre serveur Constellation avant de lancer le service (pour la Sentinel Service) ou l’application (pour la Sentinel UI).

Depuis la Console Constellation, nous pouvons observer nos deux nouvelles sentinelles (PO-SWARIN et PO-SWARIN_UI) fraichement connectées :

Installation d’une sentinelle sur un système Linux

Sur un système Linux utilisez le “Web Platform Installer” pour automatiser le processus d’installation et de configuration.

Le WPI se chargera d’installer tous les prérequis (Mono, Python, PIP, etc..) et les dernières versions des composants Constellation.

Etape 1 : lancez le “Web Platform Installer

Pour lancer le WPI entrez la commande suivante :

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

Le programme d’installation doit être lancé en “root” pour cela, le script se relancera automatiquement en “sudo” si la commande est présente. Autrement il tentera de se relancer automatiquement en “su root”. Si cette commande n’existe pas non plus, il affichera un message d’erreur. Vous aurez alors besoin de relancer manuellement le script “install.sh” en root.

Avec “sudo” ou “su root”, vous aurez dans certain cas besoin de fournir votre mot de passe “root” pour pouvoir autoriser le script d’installation à se lancer :

Le script va vérifier les prérequis à savoir :

Python (2.7 ou 3.x)
Python-dev
Mono 3.10 sur un ARMv6 ou autrement Mono 3.12 minimum
Supervisor

Sur un système Debian ou dérivé, le programme d’installation vous proposera d’installer automatiquement les prérequis si besoin.

Etape 2 : sélection des composants

Une fois les prérequis validés, vous pourrez choisir les composants Constellation à installer :

Dans ce guide, sélectionnons le composant “Sentinel”. Vous commencerez par accepter la licence d’utilisation :

Puis vous devrez renseigner vos identifiants de votre compte myConstellation.io :

Définissez ensuite le répertoire d’installation de la sentinelle sur votre système :

Etape 3 : sélection du serveur Constellation à rejoindre

Renseignez maintenant l’URI de votre serveur Constellation sur laquelle votre sentinelle doit se connecter :

Etape 4 : type d’installation de la sentinelle

Comme pour l’installation d’une sentinelle sous Windows, indiquez si vous souhaitez également procéder à son enregistrement :

Au quel cas il faudra spécifier un compte avec les droits de management pour pouvoir joindre la sentinelle dans votre Constellation :

Etape 5 : choix de la clé d’accès pour la sentinelle

Vous pourrez ensuite choisir parmi les clé d’accès configurées sur votre serveur, laquelle doit être utilisée par votre sentinelle :

Etape 6 : prérequis pour les packages Python

Enfin si vous comptez déployer des packages Constellation Python vous devez installer le runtime Python ainsi que différentes librairies (plus d’informations).

Le WPI vous proposera d’installer ces prérequis pour vous de manière automatique :

Etape 7 : installation et démarrage

Le WPI procèdera à l’installation et à la configuration de la sentinelle et des prérequis.

A la fin de ce processus, la sentinelle sera automatiquement démarrée :

En retournant sur la Console de notre Constellation, on pourra constater qu’une nouvelle sentinelle ici nommée “rpi2” s’est bien connectée dans notre Constellation :

Votre sentinelle Linux est prête, vous pouvez maintenant y déployer des packages ou développer vos propres packages en C# ou en Python.

The post Ajouter des sentinelles dans votre Constellation 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.

Auteur:	MyConstellation.io
Plateformes:	Windows
Catégorie:	Web Platform Installers
Licence:	Constellation License Agreement
Date:	juin 15, 2020