Använd IoT Central-enhetsbryggan för att ansluta andra IoT-moln till IoT Central

Artikel
10/27/2023

IoT Central-enhetsbryggan är en lösning med öppen källkod som ansluter andra IoT-moln som Sigfox, Particle Device Cloud och The Things Network till ditt IoT Central-program. Enhetsbryggan fungerar genom att vidarebefordra data från enheter som är anslutna till andra IoT-moln till ditt IoT Central-program. Enhetsbryggan vidarebefordrar endast data till IoT Central, den skickar inte kommandon eller egenskapsuppdateringar från IoT Central tillbaka till enheterna.

Med enhetsbryggan kan du kombinera kraften i IoT Central med enheter som:

Tillgångsspårningsenheter som är anslutna till Sigfox nätverk med låg effekt.
Enheter för luftkvalitetsövervakning i partikelenhetsmolnet.
Enheter för övervakning av markfuktighet i The Things Network.

Du kan använda IoT Central-programfunktioner som regler och analys av data, skapa arbetsflöden i Power Automate och Azure Logic-appar eller exportera data.

Enhetsbryggningslösningen etablerar flera Azure-resurser i din Azure-prenumeration som fungerar tillsammans för att transformera och vidarebefordra enhetsmeddelanden till IoT Central.

Förutsättningar

För att slutföra stegen i den här guiden behöver du:

En aktiv Azure-prenumeration. Om du inte har någon Azure-prenumeration skapar du ett kostnadsfritt konto innan du börjar.
Ett IoT Central-program som skapats från den anpassade programmallen . Mer information finns i Skapa ett IoT Central-program och Om ditt program.

Översikt

IoT Central-enhetsbryggan är en lösning med öppen källkod i GitHub. Den använder en anpassad Azure Resource Manager-mall för att distribuera flera resurser till din Azure-prenumeration, inklusive en funktionsapp i Azure Functions.

Funktionsappen är den centrala delen av enhetsbryggningen. Den tar emot HTTP POST-begäranden från andra IoT-plattformar via en enkel webhook. Azure IoT Central Device Bridge-lagringsplatsen innehåller exempel som visar hur du ansluter Sigfox-, Partikel- och The Things Network-moln. Du kan utöka den här lösningen för att ansluta till ditt anpassade IoT-moln om din plattform kan skicka HTTP POST-begäranden till funktionsappen.

Funktionsappen omvandlar data till ett format som godkänts av IoT Central och vidarebefordrar dem med hjälp av enhetsetableringstjänsten och enhetsklient-API:erna:

Screenshot of an Azure Functions definition showing the code.

Om ditt IoT Central-program känner igen enhets-ID:t i det vidarebefordrade meddelandet visas telemetrin från enheten i IoT Central. Om ditt IoT Central-program inte känner igen enhets-ID:t försöker funktionsappen registrera en ny enhet med enhets-ID:t. Den nya enheten visas som en ej tilldelad enhet på sidan Enheter i ditt IoT Central-program. På sidan Enheter kan du tilldela den nya enheten till en enhetsmall och sedan visa telemetrin.

Distribuera enhetsbryggningen

Så här distribuerar du enhetsbryggningen till din prenumeration:

I ditt IoT Central-program går du till sidan Behörigheter > Enhetsanslutningsgrupper .
1. Anteckna ID-omfånget. Du använder det här värdet när du distribuerar enhetsbryggningen.
2. På samma sida öppnar du registreringsgruppen SAS-IoT-Devices . På gruppsidan SAS-IoT-Devices kopierar du primärnyckeln. Du använder det här värdet när du distribuerar enhetsbryggningen.
Använd knappen Distribuera till Azure för att öppna den anpassade Resource Manager-mallen som distribuerar funktionsappen till din prenumeration. Använd ID-omfånget och primärnyckeln från föregående steg:

När distributionen är klar måste du installera npm-paketen som funktionen kräver:

Öppna funktionsappen som distribuerades till din prenumeration i Azure-portalen. Gå sedan till konsolen Utvecklingsverktyg>. I -konsolen kör du följande kommandon för att installera paketen:
```
cd IoTCIntegration
npm install
```
Det kan ta flera minuter att köra dessa kommandon. Du kan ignorera alla varningsmeddelanden på ett säkert sätt.
När paketinstallationen är klar väljer du Starta om på sidan Översikt i funktionsappen:
Funktionen är nu redo att användas. Externa system kan använda HTTP POST-begäranden för att skicka enhetsdata via enhetsbryggan till ditt IoT Central-program. Om du vill hämta funktions-URL:en går du till Functions > IoTCIntegration > Code + Test > Get-funktions-URL:

Meddelanden som skickas till enhetsbryggor måste ha följande format:

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

Varje nyckel i measurements objektet måste matcha namnet på en telemetrityp i enhetsmallen i IoT Central-programmet. Den här lösningen stöder inte att ange gränssnitts-ID:t i meddelandetexten. Så om två olika gränssnitt har en telemetrityp med samma namn visas mätningen i båda telemetriströmmarna i ditt IoT Central-program.

Du kan inkludera ett timestamp fält i brödtexten för att ange UTC-datum och tid för meddelandet. Det här fältet måste vara i ISO 8601-format. Exempel: 2020-06-08T20:16:54.602Z Om du inte inkluderar en tidsstämpel används aktuellt datum och tid.

Du kan inkludera ett modelId fält i brödtexten. Använd det här fältet om du vill tilldela enheten till en enhetsmall under etableringen.

deviceId Måste vara alfanumeriskt, gemener och kan innehålla bindestreck.

Om du inte inkluderar modelId fältet, eller om IoT Central inte känner igen modell-ID:t, skapar ett meddelande med en okänd deviceId enhet en ny otilldelad enhet i IoT Central. En operatör kan migrera enheten till rätt enhetsmall manuellt. Mer information finns i Hantera enheter i ditt Azure IoT Central-program > Migrera enheter till en mall.

Kommentar

Tills enheten har tilldelats en mall returnerar alla HTTP-anrop till funktionen en 403-felstatus.

Om du vill aktivera loggning för funktionsappen med Application Insights går du till Övervakningsloggar > i funktionsappen i Azure-portalen. Välj Aktivera Application Insights.

Etablerade resurser

Resource Manager-mallen etablerar följande resurser i din Azure-prenumeration:

Funktionsapp
App Service-plan
Storage account
Key Vault

Nyckelvalvet lagrar SAS-gruppnyckeln för ditt IoT Central-program.

Funktionsappen körs på en förbrukningsplan. Även om det här alternativet inte erbjuder dedikerade beräkningsresurser kan enhetens brygga hantera hundratals enhetsmeddelanden per minut, vilket är lämpligt för mindre flottor av enheter eller enheter som skickar meddelanden mindre ofta. Om ditt program är beroende av att strömma ett stort antal enhetsmeddelanden ersätter du förbrukningsplanen med en dedikerad App Service-plan. Den här planen erbjuder dedikerade beräkningsresurser, vilket ger snabbare svarstider för servern. Med en Standard App Service-plan var den maximala observerade prestandan för funktionen från Azure på den här lagringsplatsen cirka 1 500 enhetsmeddelanden per minut. Mer information finns i Värdalternativ för Azure Functions.

Om du vill använda en dedikerad App Service-plan i stället för en förbrukningsplan redigerar du den anpassade mallen innan du distribuerar den. Välj Redigera mall.

Screenshot that shows the edit template option for an Azure Resource Manager template.

Ersätt följande segment:

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

med

{
  "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')]"
  }
},

Redigera sedan mallen så att den tas med "alwaysOn": true i konfigurationen för resursen functionapp under "properties": {"SiteConfig": {...}} AlwaysOn-konfigurationen, vilket säkerställer att funktionsappen alltid körs.

Exempel

I följande exempel beskrivs hur du konfigurerar enhetsbryggan för olika IoT-moln:

Exempel 1: Anslut partikelenheter via enhetsbryggningen

Om du vill ansluta en partikelenhet via enhetsbryggan till IoT Central går du till partikelkonsolen och skapar en ny webhook-integrering. Ange begärandeformatet till JSON. Under Avancerat Inställningar använder du följande anpassade brödtextformat:

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

Klistra in funktions-URL :en från funktionsappen så visas Partikelenheter som otilldelade enheter i IoT Central. Mer information finns i blogginlägget Så här integrerar du dina Partikeldrivna projekt med Azure IoT Central .

Exempel 2: Anslut Sigfox-enheter via enhetsbryggan

Vissa plattformar kanske inte låter dig ange formatet för enhetsmeddelanden som skickas via en webhook. För sådana system måste du konvertera meddelandenyttolasten till det förväntade brödtextformatet innan enhetsbryggningen bearbetar den. Du kan göra konverteringen i samma funktion som kör enhetsbryggningen.

Det här avsnittet visar hur du konverterar nyttolasten för en Sigfox webhook-integrering till det brödtextformat som förväntas av enhetsbryggan. Sigfox-molnet överför enhetsdata i hexadecimalt strängformat. För enkelhetens skull innehåller enhetsbryggan en konverteringsfunktion för det här formatet, som accepterar en delmängd av de möjliga fälttyperna i en Nyttolast för Sigfox-enheter: int och uint 8, 16, 32 eller 64 bitar, float 32 bitar eller 64 bitar, little-endian och big-endian. Om du vill bearbeta meddelanden från en Sigfox webhook-integrering gör du följande ändringar i filen IoTCIntegration/index.js i funktionsappen.

Om du vill konvertera meddelandenyttolasten lägger du till följande kod före anropet till handleMessage på rad 21 och ersätter payloadDefinition med din Sigfox-nyttolastdefinition:

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)
};

Sigfox-enheter förväntar sig en 204 svarskod. Lägg till följande kod efter anropet till handleMessage på rad 21:

context.res = {
    status: 204
};

Exempel 3: Anslut enheter från The Things Network via enhetsbryggningen

Så här ansluter du Sakernas nätverksenheter till IoT Central:

Lägg till en ny HTTP-integrering i ditt program i The Things Network: Programintegreringar > > lägger till INTEGRERING > HTTP-integrering.
Kontrollera att programmet innehåller en dekodarfunktion som automatiskt konverterar nyttolasten för dina enhetsmeddelanden till JSON innan den skickas till funktionen: Programnyttolastfunktioner > > avkodare.

Följande exempel visar en JavaScript-dekoderfunktion som du kan använda för att avkoda vanliga numeriska typer från binära data:

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)
  };
}

När du har definierat integreringen lägger du till följande kod före anropet till handleMessage på rad 21 i IoTCIntegration/index.js-filen i funktionsappen. Den här koden översätter brödtexten för HTTP-integreringen till det förväntade formatet.

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

Kommentar

Det tidigare kodfragmentet använder det människovänliga enhets-ID:t. Meddelandet Things Network innehåller även ett tekniskt ID som du kan komma åt med hjälp av req.body.dev_eui.toLowerCase(). Mer information finns i The Things Network – Dataformat.

Begränsningar

Enhetsbryggan vidarebefordrar endast meddelanden till IoT Central och skickar inte meddelanden tillbaka till enheter. Den här begränsningen är anledningen till att egenskaper och kommandon inte fungerar för enheter som ansluter till IoT Central via den här enhetsbryggan. Eftersom enhetstvillingåtgärder inte stöds går det inte att uppdatera enhetsegenskaper via enhetsbryggans. Om du vill använda dessa funktioner måste en enhet ansluta direkt till IoT Central med någon av SDK:erna för Azure IoT-enheter.

Nästa steg

Nu när du har lärt dig hur du distribuerar IoT Central-enhetsbryggan föreslår vi nästa steg:

Hantera dina enheter

Dela via