Accueil Nos publications Blog Windows Phone et la maison connectée avec iJenko
.NET Mobilité
20/12/2013 5 min

Windows Phone et la maison connectée avec iJenko

iJenko Lors du week-end du 22/24 Novembre 2013, j’avais pu participer à un hackaton dédié à la maîtrise de l’énergie et la maison connectée. Florian Rousselet qui était un des membres de mon équipe a eu l’occasion d’y revenir dans un article dédié sur notre blog. Dans la liste des partenaires, plusieurs avaient attirés notre attention, et c’est de iJenko dont j’aurai l’occasion de vous parler au sein de cet article et comment mettre simplement en place une petite solution de la maîtrise de votre énergie électrique.

iJenko

La solution

iJenko est une solution de gestion intelligente de l’énergie. C’est une solution de type B2B2C (c’est-à-dire qui concerne essentiellement des clients professionnels qui s’adressent par la suite aux particuliers). Leurs offres se composent à la fois d’équipements permettant le suivi/la gestion de l’énergie et d’un portail ainsi que des services web. Nous avons pu travailler qu’avec des smartplugs (des connecteurs pour les prises électriques) et des thermomètres (faute de temps). Si vous êtes intéressés par des appareils compatibles avec cette solution, le Pack Home Pluzzy de Toshiba est exactement ce qu’il vous faudrait. Par ailleurs,  il est fort probable que Direct Energie propose à ses clients des offres avec des équipements (comme c’est déjà le cas avec d’autres fournisseurs d’énergie).

API

Je tiens tout d’abord à remercier iJenko qui m’a permet de parler davantage de cette API dont la documentation se situe à l’adresse : https://api.ijenko.net/doc .

Les APIs disponibles ne le sont qu’en REST et elles sont assez bien fournies :

  • données de consommation globale électrique du foyer, historique (en €, kWh et eqCO2)
  • données de consommation par appareil (en €, kWh et eqCO2)
  • pilotage on/off des appareils sur plugs (hifi, électroménager, lampes,…) et « ModPlugs » (module d’effacement dans le tableau électrique pour le pilotage de radiateurs électriques, chauffe-eau)
  • données de mesure de température et d’hygrométrie du foyer résultats de services comme le bilan, le suivi énergie par mois (réalisé vs objectif, corrigé des variations climatiques)
  • référentiel pour mener des analyses de modes de consommation (consommation sur la période vs semaine/mois précédent, répartition des usages en HP/HC)
  • objectifs de consommation mensuelle,
  • prévision mensuelle de conso en €
  • économies réalisées en €
  • comparaison du foyer par mois vs les foyers comparables
  • traduction de l’impact collectif sur une région des réductions mesurées d’émission de gaz à effet de serre liées à la conso électrique du foyer

Et bien d’autres encore. Pour rappel, ce n’est pas une API B2C donc, il reste quand même quelques contraintes d’utilisation. Maintenant, je vous propose de voir ensemble un peu la couche service pratique pour l’utiliser dans une application Windows Phone.

Authentification

Tout d’abord, il faut savoir que pour pouvoir utiliser l’API IJenko, il va falloir faire transiter dans les entêtes de chaque requête un token de session et avec ce token, un identifiant d’application. Aujourd’hui , l’identifiant d’application ne peut pas être obtenu par un processus automatique comme cela peut être le cas pour beaucoup d’autres APIs. IJenko gère les accès et les autorisations à son API au cas par cas (avec ses clients essentiellement).

Je créé donc un objet qui va me permettre de stocker ces données en mémoire :


    [DataContract]
    public class AuthenticationResponse
    {
    [DataMember(Name = "session_id")]
    public string SessionId { get; set; }

    [DataMember(Name = "expiry_date")]
    public DateTime ExpiryDate { get; set; }
    }

Cet objet correspond au format de la réponse généré par la méthode d’authentification /auth/session

Ainsi donc, je peux créer ma méthode d’authentification :



    private AuthenticationResponse _sessionState;
    private const string ApiBaseUrl = "https://api.ijenko.net";

    public async Task Authenticate(string login, string password)
    {
    _sessionState = null;
    var client = BuildClient();
    var request = new HttpRequestMessage(HttpMethod.Get, BuildUrl("auth/session"));
    request.Headers.Add("ijenko-login", login);
    request.Headers.Add("ijenko-password", EncodeToBase64String(password));

    var message = await client.SendAsync(request);
    var json = await GetMessageAsString(message);
    if (!string.IsNullOrEmpty(json))
    {
    _sessionState = JsonConvert.DeserializeObject<AuthenticationResponse>(json);
    }
    }

La méthode BuildClient est une petite méthode pour créer un HttpClient en forçant le type de Content au format json et la méthode BuildUrl simplement pour construire les urls de services à partir de l’url de base.


    private string BuildUrl(string part)
    {
    return string.Format("{0}/{1}", ApiBaseUrl, part);
    }

    private HttpClient BuildClient()
    {
    var client = new HttpClient();
    client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
    return client;
    }

Voilà pour la première partie. C’est une gestion simple de l’authentification (nous avions peu de temps). Maintenant que l’on est en mesure de récupérer nos informations de base pour nos requêtes, nous pouvons passer à la suite.

Gestion des appareils

J’ai eu l’occasion d’utiliser 2 types d’appareils, les smartplugs et les thermomètres. Les premiers peuvent être lus et controlés à distance (état “marche” ou “éteint”) tandis que les seconds, qui ne contiennent que des capteurs de lecture ne peuvent … qu’être lus bien entendu :-).

Si vous souhaitez récupérer la totalité des informations disponibles sur votre compte, il est possible de n’utiliser que la méthode /home .


    var sid = _sessionState.SessionId;
    var client = BuildClient();
    var url = BuildUrl("home");
    var request = new HttpRequestMessage(HttpMethod.Get, url);
    request.Headers.Add("ijenko-session-id", sid);
                request.Headers.Add("ijenko-application-id", AppId);

                var message = await client.SendAsync(request);
                var json = await GetMessageAsString(message);

Quels genres d’information sont renvoyées par la méthode /home ?

C’est un condensé des informations nécessaires aux mesures des performances énergétiques du foyer (consommation électrique , températures, appareils connectés, etc…). L’intégralité de ces informations peut être retrouvée sur leur api home.

Si vous créez une application beaucoup plus spécifique n’utilisant que peu des propriétés renvoyées par la méthode /home, il est tout à fait possible d’utiliser des méthodes spécifiques à vos besoins.

Les (smart/mods)plugs

Les plugs sont des petits boitiers qui s’installent entre votre appareil et la prise électrique. Ils permettent ainsi des mesures unitaires (et donc beaucoup plus précises) de votre consommation électrique. Dans l’API IJenko, il y a plusieurs méthodes relatives à ces plugs, à savoir des méthodes qui permettent de retrouver des informations sur la connectivité et l’identification de ces appareils et des méthodes spécifiques pour récupérer les métriques et leurs valeurs de consommation.

Récupération des informations de connectivité et d’identification

Pour récupérer la liste des plugs, en plus de la méthode /home qui renverra entre autre ces informations, il est possible de n’appeler que la méthode /home/device .


    public async Task<List<Device>> GetDevices()
    {
    if (!IsSessionValid) throw new ArgumentException("session is invalid. try to re authenticate first");
    var sid = _sessionState.SessionId;
    var client = BuildClient();
    var url = BuildUrl("home/device");
    var request = new HttpRequestMessage(HttpMethod.Get, url);
    request.Headers.Add("ijenko-session-id", sid);
    request.Headers.Add("ijenko-application-id", AppId);
    var message = await client.SendAsync(request);
    var json = await GetMessageAsString(message);
    if (!string.IsNullOrEmpty(json))
    {
    var jDevices = JObject.Parse(json).Children();
    var devices = jDevices.Select(d => d.First).Select(item => new Device
    {
    Id = item["id"].ToString(),
    Name = item["name"].ToString(),
    Powerswitch = new DevicePowerswitch()
    {
    IsAvailable = item["powerswitch"]["available"].ToString() == "true",
    IsOn = item["powerswitch"]["state"].ToString() == "on",
    IsLocked = item["powerswitch"]["locked"].ToString() == "true",
    IsReachable = item["powerswitch"]["reachable"].ToString() == "true"
    },
    Reference = new DeviceReference()
    {
    Id = item["reference"]["id"].ToString(),
    Name = item["reference"]["name"].ToString()
    }
    }).ToList();
    if (devices.Count > 0)
    {
    return devices.ToList();
    }
    }
    return null;
    }

Les thermomètres

Les thermomètres peuvent s’installer en extérieur ou en intérieur et ne renverront que des informations en lecture, à savoir la température ambiante et le pourcentage d’humidité. Pour récupérer la liste des thermomètres, il faut appeler la méthode /home/comfort .


public async Task<List<Thermometer>> GetThermometers()
{
if (!IsSessionValid)
throw new ArgumentException("session is invalid. try to re authenticate first");

var sid = _sessionState.SessionId;

var client = BuildClient();
var url = BuildUrl(string.Format("home/comfort"));

var request = new HttpRequestMessage(HttpMethod.Put, url);
request.Headers.Add("ijenko-session-id", sid);
request.Headers.Add("ijenko-application-id", AppId);

var message = await client.SendAsync(request);
var json = await GetMessageAsString(message);
if (!string.IsNullOrEmpty(json))
{
var jObject = JObject.Parse(json);
var items = jObject.Children();
var termometers = items.Select(item => item.First.ToString()).Select(JsonConvert.DeserializeObject<Responses.Comfort.Thermometer>).ToList();

var comfort = new Responses.Comfort.RootObject { Thermometer = termometers };

return
comfort.Thermometer.Select(t => new Thermometer()
{
Humidity = new ThermometerHumidity()
{
Unit = t.humidity.unit,
Value = t.humidity.value
},
Id = t.id,
Location = t.location,
Timestamp = t.timestamp,
Temperature = new ThermometerTemperature()
{
Unit = t.temperature.unit,
Value = t.temperature.value
}
}).ToList();
}

return null;
}

L’objet thermomètre a une propriété Location qui est un champ libre que renseigne l’utilisateur pour lui permettre de mieux identifier son thermomètre.

Pour aller plus loin

IJenko est une très bonne solution, un excellent départ à la maîtrise de sa consommation énergétique. Certes, il y a quelques petits défauts aujourd’hui comme par exemple, l’impossibilité de déterminer de façon précise la localisation d’un périphérique (plug ou thermomètre), cela doit passer par les champs nom ou location, ou encore le temps de cache après la mise à jour de l’état d’un plug. Mais, ce n’est pas grave car IJenko reste une solution avec un FORT potentiel pour la maison de demain. Je prendrai le soin de mettre à disposition les sources qu’on a pu produire pendant le hackathon sur GitHub. J’espère pouvoir les mettre à jour aussi assez rapidement si un jour j’ai un kit à ma disposition, pourquoi pas ? En espérant que cela vous soit utile, je vous souhaite un bon développement !

Rédigé par :

David POULIN