Blogue

Technologie
Intégrer Azure IoT : Cognitive Services et Raspberry pi
30 novembre 2017
par Eduardo Mazza & Marc Bourdeau

Au cours des dernières années, Microsoft a fait un effort considérable pour offrir un outil de développement simple pour les applications destinées aux appareils IoT. Cet investissement est sans nul doute lié aux estimations concernant le nombre d’appareils IoT qui seront éventuellement utilisés, soit près de 40 milliards, ou environ 30 appareils par utilisateur de réseaux sociaux.

Dans cet article, nous décrirons à quel point il est facile de développer pour les appareils IoT en utilisant les technologies et les outils fournis par Microsoft. De plus, nous montrerons comment intégrer un appareil IoT aux Cognitive Services de Microsoft Azure.

 

Le projet

Le projet consiste en une interface en ligne de commande qui interprétera les ordres donnés (en format texte) via l’interface de l’appareil IoT et les capteurs actifs. L’appareil IoT choisi est le Raspberry Pi 3 (modèle B) qui se compose d’un ordinateur de la taille d’une carte de crédit pouvant se brancher à un écran et à un clavier et qui peut être utilisé dans le cadre de divers projets électroniques.

Outre le Raspberry Pi, nous utiliserons également ces quelques pièces de matériel :

1 x adaptateur secteur pour le Pi 5V 2.5A (parfois vendu séparément)
1 x plaque d’essai (breadboard)
2 x résistances 20 Ohms
4 x fils de connexions temporaires
2 x DEL de 2 couleurs différentes (verte et jaune pour cette démonstration)

Pour configurer le matériel dans le cadre de ce projet, suivez les étapes suivantes :

DEL verte :

DEL jaune :

Notez que la polarité de la DEL est importante. (Cette configuration est communément appelée Active Low [actif au niveau bas]).

Une fois terminée, votre configuration devrait ressembler à ceci :

 

Commencer à coder – faire fonctionner les lumières

Pour faciliter le codage, nous avons adapté un exemple de projet appelé « Blinky » (essentiellement, le projet Hello World pour les appareils IoT) qui contient le code pour alimenter une DEL sur une plaque d’essai. Commencez par configurer et connecter votre Raspberry Pi avec Visual Studio à l’aide du didacticiel suivant : https://developer.microsoft.com/en-us/windows/iot/getstarted

Dès que vous êtes en mesure d’exécuter du code dans le Raspberry Pi à partir de Visual Studio, téléchargez le code source du projet à partir de l’hébergeur de code source GitHub.

Le cœur du projet qui doit lancer la fonction InitGPIO se trouve sur la page « MainPage class » :

private void InitGPIO()
{
    var gpio = GpioController.GetDefault();
    pinGreen = gpio.OpenPin(LED_GREEN_PIN);
    pinYellow = gpio.OpenPin(LED_YELLOW_PIN);
    pinGreen.SetDriveMode(GpioPinDriveMode.Output);
    pinYellow.SetDriveMode(GpioPinDriveMode.Output);
}

Fondamentalement, cette méthode configure le périphérique IoT pour qu’il contrôle la puissance de sortie sur les broches 5 et 6 du Raspberry Pi (représenté respectivement ici par les constantesLED_GREEN_PIN et YELLOW_GREEN_PIN respectivement).

… et c’est tout ! Maintenant, le seul code à exécuter pour allumer la DEL verte est :

pinGreen.Write(GpioPinValue.Low);

Un jeu d’enfant, non ?

 

Créer des API Cognitive Services

Maintenant que nous savons comment allumer/éteindre les lumières en utilisant notre matériel, il est temps d’apprendre à l’appareil comment interpréter une commande.  

Disons que nous voulons qu’il réponde à la commande « Je veux allumer la DEL verte » de la même façon qu’à la commande « Allumer DEL verte, maintenant ». Pour ce faire, nous utiliserons un service (parmi les différents proposés par Microsoft Cognitive Services) appelé LUIS (Language Understanding Intelligent Service). Comme décrit dans la documentation de LUIS :

« LUIS permet aux développeurs de créer des applications intelligentes capables de comprendre le langage humain et de réagir en conséquence aux demandes des utilisateurs. »

Fondamentalement, nous allons fournir à LUIS une phrase écrite et obtenir en sortie une structure JSON qui décrit les intentions et les entités possibles contenues dans la phrase donnée (et à quel point le service est sûr d’obtenir les résultats attendus).

Pour créer et configurer LUIS, nous avons suivi le tutoriel sur https://docs.microsoft.com/fr-ca/azure/cognitive-services/luis/luis-get-started-create-app et nous avons simplement ajouté trois entités (une lumière verte, une lumière jaune et les deux lumières ensemble) et deux intentions (allumer et éteindre).

Enfin, nous avons ajouté quelques phrases pour entraîner notre service à comprendre nos commandes. Des phrases telles que « lumière verte allumée », « je veux que la lumière verte soit allumée » et « s’il vous plaît, allumez la lumière verte » sont quelques exemples d’ordres faisant comprendre à notre application qu’elle doit allumer la lumière verte.

Une fois entraînée, nous avons publié notre application. Le résultat de cette publication est un service REST capable de recevoir des requêtes et de générer une réponse en JSON qui décrit l’action possible (Lumière allumée [LightOn] ou Lumière éteinte [LightOff]) et les entités impliquées (Lumière verte [Green], Lumière jaune [Yellow] ou Lumière ensemble [AllLights]).

 

 

Tout intégrer

Nous en avons presque terminé. La dernière étape consiste à introduire le code nécessaire pour communiquer avec le service REST créé à l’étape précédente et à introduire ses sorties.

Microsoft propose différentes bibliothèques (sous forme de paquets NuGet) qui implémentent déjà l’intégration de nombreuses API Cognitive Services. Ces paquets utilisent le préfixe « Microsoft.ProjectOxford » (Project Oxford était le nom précédent de Cognitive Services) — https://www.nuget.org/packages?q=Microsoft.ProjectOxford.

Cependant, tous les services ne sont pas disponibles, et lorsqu’ils le sont, tous ne possèdent pas une version capable de fonctionner avec les appareils IoT. Dans notre cas, nous avons simplement besoin de développer une classe qui communiquera avec le point de terminaison du service REST. D’abord, nous créons une méthode pour faire une requête GET à une URL donnée :

private static async Task<string> Get(string url)
{
    HttpClient client = new HttpClient();
    HttpResponseMessage response = await client.GetAsync(new Uri(url));
    var responseString = await response.Content.ReadAsStringAsync();
    return responseString;
}

Ensuite, nous n’avons qu’à créer une classe qui contient les valeurs de la sortie :

public class Command
{
    public Intent Intent { get; set; }
    public Entity Entity { get; set; }
}
public enum Entity
{
    Green,
    Yellow,
    All
}
public enum Intent
{
    LightOn,
    LightOff,
    None
}

Enfin, nous créons la méthode qui transmet la requête au service REST et analyse le JSON qui en résulte :

public static async Task<Command> Order(string sentence)
{
    var result = new Command { Entity = Entity.All, Intent = Intent.None };
    var queryUrl = LuisUrl + sentence;
    var resultJson = await Get(queryUrl);

    //read json and turn into command
    JsonObject obj = JsonObject.Parse(resultJson);

    //read intent
    var intent = obj["topScoringIntent"].GetObject()["intent"].GetString();
    switch (intent)
    {
        case "LightOn":
            result.Intent = Intent.LightOn;
            break;
        case "LightOff":
            result.Intent = Intent.LightOff;
            break;
        default:
            break;
    }

    //read entity
    var entity = obj["entities"];
    if (entity.GetArray().Any())
    {
        var entityLight = obj["entities"].GetArray()[0].GetObject()["type"].ToString().Replace("\"","");
        switch (entityLight)
        {
            case "AllLight":
                result.Entity = Entity.All;
                break;
            case "Green":
                result.Entity = Entity.Green;
                break;
            case "Yellow":
                result.Entity = Entity.Yellow;
                break;
            default:
                break;
        }
    }
    return result;
}

Les classes permettant d’accéder à un client Web et d’analyser la chaîne JSON se trouvent respectivement dans les espaces de noms Windows.Web.Http et Windows.Data.Json.

Et c’est tout… en quelques minutes, avec quelques lignes de code, notre appareil IoT est maintenant capable de comprendre nos commandes :

 

Conclusion

Un grand nombre de projets, allant de l’automatisation des tâches à la surveillance de machines, peuvent être conçus à partir des appareils IoT. Les amateurs les utiliseront pour des projets personnels et les entreprises pour de plus grands projets qui leur ajouteront de la valeur. De plus, la capacité de connecter ces appareils à des API externes, telles que celles de Cognitive Services, ouvre des possibilités dont les seules limites sont dictées par notre imagination.