Utiliser le pont d’appareil IoT Central pour connecter d’autres clouds IoT à IoT Central

Le pont d’appareil IoT Central est une solution open source qui connecte d’autres clouds IoT tels que Sigfox, Particle Device Cloud et The Things Network à votre application IoT Central. Le pont d’appareil fonctionne en transférant des données à partir d’appareils connectés à d’autres clouds IoT via votre application IoT Central. Le pont d’appareil transfère uniquement les données vers IoT Central, il n’envoie pas de commandes ni de mises à jour de propriétés d’IoT Central aux appareils.

Le pont d’appareil vous permet de combiner la puissance d’IoT Central avec des appareils tels que :

Appareils de suivi des ressources connectés au réseau à faible puissance de Sigfox.
Dispositifs de surveillance de la qualité de l’air sur le Particle Device Cloud.
Appareils de surveillance de l’humidité du sol sur le réseau Things.

Vous pouvez utiliser des fonctionnalités d’application IoT Central, telles que des règles et des analyses sur les données, créer des flux de travail dans Power Automate et azure Logic Apps ou exporter les données.

La solution de pont d’appareil provisionne plusieurs ressources Azure dans votre abonnement Azure qui fonctionnent ensemble pour transformer et transférer des messages d’appareil vers IoT Central.

Prerequisites

Pour suivre les étapes décrites dans ce guide pratique, vous avez besoin des éléments suivants :

Un abonnement Azure actif. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Application IoT Central créée à partir du modèle d’application personnalisé . Pour en savoir plus, consultez Créer une application IoT Central et Comment obtenir des informations sur mon application ?.

Aperçu

La passerelle de dispositifs IoT Central est une solution open source sur GitHub. Il utilise un modèle Azure Resource Manager personnalisé pour déployer plusieurs ressources dans votre abonnement Azure, y compris une application de fonction dans Azure Functions.

L’application de fonction est l’élément principal du pont d’appareil. Il reçoit des requêtes HTTP POST à partir d’autres plateformes IoT via un webhook simple. Le référentiel Azure IoT Central Device Bridge inclut des exemples qui montrent comment connecter Sigfox, Particle et The Things Network clouds. Vous pouvez étendre cette solution pour vous connecter à votre cloud IoT personnalisé si votre plateforme peut envoyer des requêtes HTTP POST à votre application de fonction.

L’application de fonction transforme les données dans un format accepté par IoT Central et les transfère à l’aide du service d’approvisionnement d’appareils et des API clientes d’appareil :

Capture d’écran d’une définition Azure Functions montrant le code.

Si votre application IoT Central reconnaît l’ID d’appareil dans le message transféré, les données de télémétrie de l’appareil s’affichent dans IoT Central. Si votre application IoT Central ne reconnaît pas l’ID d’appareil, l’application de fonction tente d’inscrire un nouvel appareil avec l’ID d’appareil. Le nouvel appareil apparaît sous la forme d’un appareil non attribué sur la page Appareils de votre application IoT Central. Dans la page Appareils , vous pouvez affecter le nouvel appareil à un modèle d’appareil, puis afficher les données de télémétrie.

Déployer le pont d’appareil

Pour déployer le pont d’appareil dans votre abonnement :

Dans votre application IoT Central, accédez à la page Permissions : Groupes de connexion d’appareils.
1. Notez l’étendue de l’ID. Vous utilisez cette valeur lorsque vous déployez le pont de périphérique.
2. Dans la même page, ouvrez le groupe d’inscription SAS-IoT-Devices . Sur la page du groupe SAS-IoT-Devices, copiez la clé primaire. Vous utilisez cette valeur lorsque vous déployez le pont de périphérique.
Utilisez le bouton Déployer sur Azure suivant pour ouvrir le modèle Resource Manager personnalisé qui déploie l’application de fonction sur votre abonnement. Utilisez ID Scope et la clé primaire de l’étape précédente :

Une fois le déploiement terminé, vous devez installer les packages npm dont la fonction a besoin :

Dans le portail Azure, ouvrez l’application de fonction déployée sur votre abonnement. Ensuite, accédez à laconsole> de développement. Dans la console, exécutez les commandes suivantes pour installer les packages :
```
cd IoTCIntegration
npm install
```
Ces commandes peuvent prendre plusieurs minutes. Vous pouvez ignorer en toute sécurité les messages d’avertissement.
Une fois l’installation du package terminée, sélectionnez Redémarrer dans la page Vue d’ensemble de l’application de fonction :
La fonction est maintenant prête à être utilisée. Les systèmes externes peuvent utiliser des requêtes HTTP POST pour envoyer des données d’appareil via le pont de l’appareil dans votre application IoT Central. Pour obtenir l’URL de la fonction, accédez à Functions > IoTCIntegration > Code + Test > Get function URL :

Les corps de messages envoyés au pont de l’appareil doivent avoir le format suivant :

"device": {
  "deviceId": "my-cloud-device"
},
"measurements": {
  "temp": 20.31,
  "pressure": 50,
  "humidity": 8.5,
  "ledColor": "blue"
}

Chaque clé de l’objet measurements doit correspondre au nom d’un type de télémétrie dans le modèle d’appareil dans l’application IoT Central. Cette solution ne prend pas en charge la spécification de l’ID d’interface dans le corps du message. Par conséquent, si deux interfaces différentes ont un type de télémétrie portant le même nom, la mesure apparaît dans les deux flux de télémétrie dans votre application IoT Central.

Vous pouvez inclure un timestamp champ dans le corps pour spécifier la date et l’heure UTC du message. Ce champ doit être au format ISO 8601. Par exemple : 2020-06-08T20:16:54.602Z. Si vous n’incluez pas d’horodatage, la date et l’heure actuelles sont utilisées.

Vous pouvez inclure un champ modelId dans le corps. Utilisez ce champ pour affecter l’appareil à un modèle d’appareil pendant l’approvisionnement.

La deviceId valeur doit être alphanumérique, minuscule et peut contenir des traits d’union.

Si vous n’incluez pas le modelId champ ou si IoT Central ne reconnaît pas l’ID de modèle, un message avec un appareil non reconnu deviceId crée un appareil non attribué dans IoT Central. Un opérateur peut migrer manuellement l’appareil vers le modèle d’appareil approprié. Pour plus d’informations, consultez Gérer les appareils dans votre application > Azure IoT Central Migration d’appareils vers un modèle.

Note

Tant que l’appareil n’est pas affecté à un modèle, tous les appels HTTP à la fonction retournent un état d’erreur 403.

Pour activer la journalisation de l’application de fonction avec Application Insights, accédez à Monitoring > Journaux dans votre application de fonction dans le portail Azure. Sélectionnez Activer Application Insights.

Ressources approvisionnées

Le modèle Resource Manager provisionne les ressources suivantes dans votre abonnement Azure :

Conteneur de fonctions
Plan App Service
Compte de stockage
Coffre de clés

Le coffre de clés stocke la clé de groupe SAP pour votre application IoT Central.

L’application de fonction s’exécute sur un plan de consommation. Bien que cette option n’offre pas de ressources de calcul dédiées, elle permet au pont de l’appareil de gérer des centaines de messages d’appareil par minute, adaptés à des flottes plus petites d’appareils ou d’appareils qui envoient des messages moins fréquemment. Si votre application dépend de la diffusion en continu d’un grand nombre de messages d’appareil, remplacez le plan de consommation par un plan App Service dédié. Ce plan offre des ressources de calcul dédiées, ce qui accélère les temps de réponse du serveur. Avec un plan App Service standard, les performances maximales observées de la fonction à partir d’Azure dans ce référentiel étaient d’environ 1 500 messages d’appareil par minute. Pour en savoir plus, consultez les options d’hébergement d’Azure Functions.

Pour utiliser un plan App Service dédié au lieu d’un plan de consommation, modifiez le modèle personnalisé avant le déploiement. Sélectionnez Modifier le modèle.

Capture d’écran montrant l’option modifier le modèle pour un modèle Azure Resource Manager.

Remplacez le segment suivant :

{
  "type": "Microsoft.Web/serverfarms",
  "apiVersion": "2015-04-01",
  "name": "[variables('planName')]",
  "location": "[resourceGroup().location]",
  "properties": {
    "name": "[variables('planName')]",
    "computeMode": "Dynamic",
    "sku": "Dynamic"
  }
},

Avec:

{
  "type": "Microsoft.Web/serverfarms",
  "sku": {
      "name": "S1",
      "tier": "Standard",
      "size": "S1",
      "family": "S",
      "capacity": 1
  },
  "kind": "app",
  "name": "[variables('planName')]",
  "apiVersion": "2016-09-01",
  "location": "[resourceGroup().location]",
  "tags": {
      "iotCentral": "device-bridge",
      "iotCentralDeviceBridge": "app-service-plan"
  },
  "properties": {
      "name": "[variables('planName')]"
  }
},

Ensuite, modifiez le modèle pour inclure "alwaysOn": true dans la configuration de la ressource functionapp sous "properties": {"SiteConfig": {...}}. La configuration alwaysOn garantit que l'application fonctionnelle est exécutée en permanence.

Examples

Les exemples suivants décrivent comment configurer le pont d’appareil pour différents clouds IoT :

Exemple 1 : Connexion des appareils Particle via le device bridge

Pour connecter un appareil Particle via le pont d’appareil à IoT Central, accédez à la console Particle et créez une intégration de webhook. Définissez le format de requête sur JSON. Sous Paramètres avancés, utilisez le format de corps personnalisé suivant :

{
  "device": {
    "deviceId": "{{{PARTICLE_DEVICE_ID}}}"
  },
  "measurements": {
    "{{{PARTICLE_EVENT_NAME}}}": "{{{PARTICLE_EVENT_VALUE}}}"
  }
}

Collez l’URL de la fonction à partir de votre application de fonction, et vous verrez les appareils Particle apparaître comme des appareils non assignés dans IoT Central. Pour plus d’informations, consultez le billet de blog sur comment intégrer vos projets utilisant la technologie Particle avec Azure IoT Central.

Exemple 2 : Connexion d’appareils Sigfox via le pont d’appareil

Certaines plateformes peuvent ne pas vous permettre de spécifier le format des messages d’appareil envoyés via un webhook. Pour ces systèmes, vous devez convertir la charge utile de message au format de corps attendu avant que le pont d’appareil ne la traite. Vous pouvez effectuer la conversion dans la fonction qui exécute le pont d'appareil.

Cette section montre comment convertir la charge utile d’une intégration de webhook Sigfox au format de corps attendu par le pont d’appareil. Le cloud Sigfox transmet les données d’appareil au format de chaîne hexadécimale. Par commodité, le pont d’appareil inclut une fonction de conversion pour ce format, qui accepte un sous-ensemble des types de champs possibles dans une charge utile d’appareil Sigfox : champs int et uint de 8, 16, 32 ou 64 bits ; champs float de 32 bits ou 64 bits, champs little-endian et big-endian. Pour traiter les messages d’une intégration de webhook Sigfox, apportez les modifications suivantes au fichier IoTCIntegration/index.js dans l’application de fonction.

Pour convertir la charge utile du message, ajoutez le code suivant avant l’appel à handleMessage sur la ligne 21, en remplaçant payloadDefinition par votre définition de charge utile Sigfox :

const payloadDefinition = 'gforce::uint:8 lat::uint:8 lon::uint:16'; // Replace this with your payload definition

req.body = {
    device: {
        deviceId: req.body.device
    },
    measurements: require('./converters/sigfox')(payloadDefinition, req.body.data)
};

Les appareils Sigfox attendent un 204 code de réponse. Ajoutez le code suivant après l’appel à handleMessage à la ligne 21 :

context.res = {
    status: 204
};

Exemple 3 : Connexion d’appareils à partir du réseau Things via le pont de l’appareil

Pour connecter les appareils Things Network à IoT Central :

Ajoutez une nouvelle intégration HTTP à votre application dans The Things Network : Les intégrations > d’applications > ajoutent l’intégration > HTTP.
Assurez-vous que votre application inclut une fonction de décodeur qui convertit automatiquement la charge utile de vos messages d’appareil en JSON avant de l’envoyer à la fonction : décodeur des fonctions > de charge utile d’application>.

L’exemple suivant montre une fonction de décodeur JavaScript que vous pouvez utiliser pour décoder les types numériques courants à partir de données binaires :

function Decoder(bytes, port) {
  function bytesToFloat(bytes, decimalPlaces) {
    var bits = (bytes[3] << 24) | (bytes[2] << 16) | (bytes[1] << 8) | bytes[0];
    var sign = (bits >>> 31 === 0) ? 1.0 : -1.0;
    var e = bits >>> 23 & 0xff;
    var m = (e === 0) ? (bits & 0x7fffff) << 1 : (bits & 0x7fffff) | 0x800000;
    var f = Math.round((sign * m * Math.pow(2, e - 150)) * Math.pow(10, decimalPlaces)) / Math.pow(10, decimalPlaces);
    return f;
  }

  function bytesToInt32(bytes, signed) {
    var bits = bytes[0] | (bytes[1] << 8) | (bytes[2] << 16) | (bytes[3] << 24);
    var sign = 1;

    if (signed && bits >>> 31 === 1) {
      sign = -1;
      bits = bits & 0x7FFFFFFF;
    }

    return bits * sign;
  }

  function bytesToShort(bytes, signed) {
    var bits = bytes[0] | (bytes[1] << 8);
    var sign = 1;

    if (signed && bits >>> 15 === 1) {
      sign = -1;
      bits = bits & 0x7FFF;
    }

    return bits * sign;
  }

  return {
    temperature: bytesToFloat(bytes.slice(0, 4), 2),
    presscounter: bytesToInt32(bytes.slice(4, 8), true),
    blueLux: bytesToShort(bytes.slice(8, 10), false)
  };
}

Après avoir défini l’intégration, ajoutez le code suivant avant l’appel à handleMessage sur la ligne 21 du fichier IoTCIntegration/index.js de votre application de fonction. Ce code traduit le corps de votre intégration HTTP au format attendu.

req.body = {
  device: {
    deviceId: req.body.end_device_ids.device_id.toLowerCase()
  },
  measurements: req.body.uplink_message.decoded_payload
};

Note

L’extrait de code précédent utilise l’ID d’appareil convivial. Le message Things Network inclut également un ID technique auquel vous pouvez accéder à l’aide req.body.dev_eui.toLowerCase(). Pour plus d’informations, consultez The Things Network - Data Formats.

Limites

Le pont de l’appareil transfère uniquement les messages à IoT Central et ne renvoie pas de messages aux appareils. Cette limitation est la raison pour laquelle les propriétés et les commandes ne fonctionnent pas pour les appareils qui se connectent à IoT Central via ce pont d’appareil. Étant donné que les opérations de représentation d’appareil ne sont pas prises en charge, il n’est pas possible de mettre à jour les propriétés des appareils via le pont d’appareil. Pour utiliser ces fonctionnalités, un appareil doit se connecter directement à IoT Central à l’aide de l’un des SDK Azure IoT pour appareils.

Rétroaction

Cette page vous a-t-elle été utile ?

Last updated on 2025-09-24