Share via

Transformera data i ditt IoT Central-program för export

  • Artikel

IoT-enheter skickar data i olika format. Om du vill använda enhetsdata i din IoT-lösning kan du behöva transformera dina enhetsdata innan de exporteras till andra tjänster.

Den här artikeln visar hur du transformerar enhetsdata som en del av en dataexportdefinition i ett IoT Central-program.

Med transformeringar i en IoT Central-dataexportdefinition kan du ändra formatet och strukturen för enhetsdata innan de exporteras till ett mål. Du kan ange en transformering för varje mål i en exportdefinition. Varje meddelande skickas genom omvandlingen för att skapa en utdatapost som exporteras till målet.

Använd transformeringar för att omstrukturera JSON-nyttolaster, byta namn på fält, filtrera bort fält och köra enkla beräkningar på telemetrivärden. Använd till exempel en transformering för att konvertera dina meddelanden till ett tabellformat som matchar schemat för ett mål, till exempel en Azure Data Explorer-tabell.

I följande video presenteras IoT Central-datatransformeringar:

Lägga till en transformering

Om du vill lägga till en transformering för ett mål i din dataexport väljer du + Transformera enligt följande skärmbild:

Screenshot that shows how to add a transformation to a destination.

På panelen Datatransformering kan du ange omvandlingen. I 1en . Lägg till indatameddelandeavsnittet . Du kan ange ett exempelmeddelande som du vill skicka genom omvandlingen. Du kan också generera ett exempelmeddelande genom att välja en enhetsmall. I 2na . I avsnittet Skapa transformeringsfråga kan du ange frågan som transformerar indatameddelandet. 3na . Avsnittet Förhandsgranska utdatameddelanden visar resultatet av omvandlingen:

Screenshot of transformation editor in IoT Central.

Dricks

Om du inte känner till formatet för indatameddelandet använder . du som fråga för att exportera meddelandet som det är till ett mål, till exempel en Webhook. Klistra sedan in meddelandet som tas emot av webhooken i 1. Lägg till indatameddelandet. Skapa sedan en transformeringsfråga för att bearbeta det här meddelandet till önskat utdataformat.

Skapa en transformeringsfråga

Transformmotorn använder JQ JSON-processorn med öppen källkod för att omstrukturera och formatera JSON-nyttolaster. Om du vill ange en transformering skriver du en JQ-fråga som kan använda de inbyggda filtren, funktionerna och funktionerna i JQ. Några frågeexempel finns i Exempel på transformeringsfrågor. Mer information om hur du skriver JQ-frågor finns i JQ-handboken.

Meddelandestruktur före omvandling

Du kan exportera följande dataströmmar från IoT Central: telemetri, egenskapsändringar, enhetsanslutningshändelser, händelser i enhetens livscykel och livscykelhändelser för enhetsmallar. Varje typ av data har en specifik struktur som innehåller information som telemetrivärden, programinformation, enhetsmetadata och egenskapsvärden.

I följande exempel visas formen på telemetrimeddelandet. Alla dessa data är tillgängliga för din omvandling. Meddelandets struktur är liknande för andra meddelandetyper, men det finns vissa typspecifika fält. Du kan använda funktionen Lägg till indatameddelande för att generera ett exempelmeddelande baserat på en enhetsmall i ditt program.

{
  "applicationId": "93d68c98-9a22-4b28-94d1-06625d4c3d0f",
  "device": {
    "id": "31edabe6-e0b9-4c83-b0df-d12e95745b9f",
    "name": "Scripted Device - 31edabe6-e0b9-4c83-b0df-d12e95745b9f",
    "cloudProperties": [],
    "properties": {
      "reported": [
        {
          "id": "urn:smartKneeBrace:Smart_Vitals_Patch_wr:FirmwareVersion:1",
          "name": "FirmwareVersion",
          "value": 1.0
        }
      ]
    },
    "templateId": "urn:sbq3croo:modelDefinition:nf7st1wn3",
    "templateName": "Smart Knee Brace"
  },
  "telemetry": [
      {
        "id": "urn:continuousPatientMonitoringTemplate:Smart_Knee_Brace_6wm:Acceleration:1",
        "name": "Acceleration",
        "value": {
          "x": 19.212770659918583,
          "y": 20.596296675217335,
          "z": 54.04859440697045
        }
      },
      {
        "id": "urn:continuousPatientMonitoringTemplate:Smart_Knee_Brace_6wm:RangeOfMotion:1",
        "name": "RangeOfMotion",
        "value": 110
      }
  ],
  "enqueuedTime": "2021-03-23T19:55:56.971Z",
  "enrichments": {
      "your-enrichment-key": "enrichment-value"
  },
  "messageProperties": {
      "prop1": "prop-value"
  },
  "messageSource": "telemetry"
}

Dricks

Använd funktionen Lägg till indatameddelande i IoT Central-programgränssnittet för att se exempel på meddelandestrukturer för andra typer av dataexport, till exempel egenskapsändringar.

Exempel på transformeringsfrågor

I följande frågeexempel används telemetrimeddelandet som visas i föregående avsnitt.

Exempel 1: Följande JQ-fråga matar ut varje bit telemetri från indatameddelandet som ett separat utdatameddelande:

.telemetry[]

JSON-utdata:

{
  "id": "urn:continuousPatientMonitoringTemplate:Smart_Knee_Brace_6wm:Acceleration:1",
  "name": "Acceleration",
  "value": {
    "x": 19.212770659918583,
    "y": 20.596296675217335,
    "z": 54.04859440697045
  }
},
{
  "id": "urn:continuousPatientMonitoringTemplate:Smart_Knee_Brace_6wm:RangeOfMotion:1",
  "name": "RangeOfMotion",
  "value": 110
}

Dricks

Om du vill ändra utdata till ett enda meddelande med en matris med telemetrityper använder du frågan .telemetry.

Exempel 2: Följande JQ-fråga konverterar indatatelemetrimatrisen till ett objekt med telemetrinamn som nycklar:

.telemetry | map({ key: .name, value: .value }) | from_entries

JSON-utdata:

{
  "Acceleration": {
    "x": 19.212770659918583,
    "y": 20.596296675217335,
    "z": 54.04859440697045
  },
  "RangeOfMotion": 110
}

Exempel 3: Följande JQ-fråga hittar telemetrivärdet RangeOfMotion och konverterar det från grader till radianer med hjälp av formeln rad = degree * pi / 180. Den här frågan visar också hur du importerar och använder modulen iotc :

import "iotc" as iotc;
{
  rangeOfMotion: (
    .telemetry
    | iotc::find(.name == "RangeOfMotion").value
    | . * 3.14159265358979323846 / 180
  )
}

JSON-utdata:

{
  "rangeOfMotion": 1.9198621771937625
}

Exempel 4: Om du vill ändra indatameddelandet till ett tabellformat kan du mappa varje exporterat meddelande till en eller flera rader. Radutdata representeras logiskt som ett JSON-objekt där kolumnnamnet är nyckeln och kolumnvärdet är värdet:

{
    "<column 1 name>": "<column 1 value>",
    "<column 2 name>": "<column 2 value>",
    ...
}

Dricks

Använd ett tabellformat när du exporterar till Azure Data Explorer.

Följande JQ-fråga skriver rader till en tabell som lagrar rangeOfMotion-telemetri på olika enheter. Frågan mappar enhets-ID, tidsåtgång och rörelseomfång till en tabell med följande kolumner:

import "iotc" as iotc;
{
    deviceId: .deviceId,
    timestamp: .enqueuedTime,
    rangeOfMotion: .telemetry | iotc::find(.name == "RangeOfMotion").value
}

Utdata i JSON-format:

{
  "deviceId": "31edabe6-e0b9-4c83-b0df-d12e95745b9f",
  "timestamp": "2021-03-23T19:55:56.971Z",
  "rangeOfMotion": 110
}

IoT Central-modul

En JQ-modul är en samling anpassade funktioner. Som en del av transformeringsfrågan kan du importera en inbyggd IoT Central-specifik modul som innehåller funktioner för att göra det enklare för dig att skriva dina frågor. Om du vill importera IoT Central-modulen använder du följande direktiv:

import "iotc" as iotc;

IoT Central-modulen innehåller följande funktioner:

find(expression): Med find funktionen kan du hitta ett specifikt matriselement, till exempel telemetrivärde eller egenskapspost i nyttolasten. Funktionsindata är en matris och parametern definierar ett JQ-filter som ska köras mot varje element i matrisen. Funktionen returnerar varje matriselement där filtret utvärderas till sant:

Om du till exempel vill hitta ett specifikt telemetrivärde med namnet RangeOfMotion:

.telemetry | iotc::find(.name == "RangeOfMotion")

Scenarier

Följande scenarier använder transformeringsfunktionen för att anpassa enhetens dataformat för ett visst mål.

Scenario 1: Exportera enhetsdata till Azure Data Explorer

I det här scenariot transformerar du enhetsdata så att de matchar det fasta schemat i Azure Data Explorer, där varje telemetrivärde visas som en kolumn i tabellen och varje rad representerar ett enda meddelande. Till exempel:

DeviceId Tidsstämpel T1 T2 T3
"31edabe6-e0b9-4c83-b0df-d12e95745b9f" "2021-03-23T19:55:56.971Z 1.18898 1.434709 2.97008

Om du vill exportera data som är kompatibla med den här tabellen måste varje exporterat meddelande se ut som följande objekt. Objektet representerar en enskild rad, där nycklarna är kolumnnamn och värdena är det värde som ska placeras i varje kolumn:

{
    "Timestamp": <value-of-Timestamp>,
    "DeviceId": <value-of-deviceId>,
    "T1": <value-of-T1>,
    "T2": <value-of-T2>,
    "T3": <value-of-T3>,
}

I det här scenariot skickar enheten telemetrivärdena t1, t2och t3 i ett indatameddelande som ser ut som i följande exempel:

{
  "applicationId": "c57fe8d9-d15d-4659-9814-d3cc38ca9e1b",
  "enqueuedTime": "1933-01-26T03:10:44.480001324Z",
  "messageSource": "telemetry",
  "telemetry": [
    {
      "id": "dtmi:temperaturesensor288:sensors1lr:t1;1",
      "name": "t1",
      "value": 1.1889838348731093e+308
    },
    {
      "id": "dtmi:temperaturesensor288:sensors1lr:t2;1",
      "name": "t2",
      "value": 1.4347093391531383e+308
    },
    {
      "id": "dtmi:temperaturesensor288:sensors1lr:t3;1",
      "name": "t3",
      "value": 2.9700885230380616e+307
    }
  ],
  "device": {
    "id": "oozrnl1zs857",
    "name": "haptic alarm",
    "templateId": "dtmi:modelDefinition:nhhbjotee:qytxnp8hi",
    "templateName": "hapticsensors",
    "properties": {
      "reported": []
    },
    "cloudProperties": [],
    "simulated": true,
    "approved": false,
    "blocked": false,
    "provisioned": true
  }
}

Följande JQ-fråga matar ut T1värdena , T2 och T3 telemetri, Timestamp och deviceId som ett meddelande med nyckel/värde-par som matchar tabellschemat i Azure Data Explorer:

import "iotc" as iotc;
{
  deviceId: .device.id,
  Timestamp: .enqueuedTime,
  T1: .telemetry | iotc::find(.name == "t1").value,
  T2: .telemetry | iotc::find(.name == "t2").value,
  T3: .telemetry | iotc::find(.name == "t3").value,
}

JSON-utdata:

{
  "T1": 1.1889838348731093e+308,
  "T2": 1.4347093391531383e+308,
  "T3": 2.9700885230380616e+307,
  "Timestamp": "1933-01-26T03:10:44.480001324Z",
  "deviceId": "oozrnl1zs857"
}

Mer information om hur du lägger till ett Azure Data Explorer-kluster och en databas som exportmål finns i Skapa ett Azure Data Explorer-mål.

Scenario 2: Dela upp en telemetrimatris

I det här scenariot skickar enheten följande telemetrimatris i ett meddelande:

{
  "applicationId": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "enqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "messageSource": "telemetry",
  "telemetry": [
    {
      "id": "dtmi:sample1:data;1",
      "name": "data",
      "value": [
        {
          "id": "subdevice1",
          "values": {
              "running": true,
              "cycleCount": 2315
          }
        },
        {
          "id": "subdevice2",
          "values": {
              "running": false,
              "cycleCount": 824567
          }
        }
      ]
    },
    {
      "id": "dtmi:sample1:parentStatus;1",
      "name": "parentStatus",
      "value": "healthy"
    }
  ],
  "device": {
    "id": "9xwhr7khkfri",
    "name": "wireless port",
    "templateId": "dtmi:hpzy1kfcbt2:umua7dplmbd",
    "templateName": "Smart Vitals Patch",
    "properties": {
      "reported": [
        {
          "id": "dtmi:sample1:prop;1",
          "name": "Connectivity",
          "value": "Tenetur ut quasi minus ratione voluptatem."
        }
      ]
    },
    "cloudProperties": [],
    "simulated": true,
    "approved": true,
    "blocked": false,
    "provisioned": false
  }
}

Du vill transformera dessa enhetsdata så att de matchar följande tabellschema:

cycleCount deviceId enqueuedTime parentStatus körs subdeviceId
2315 "9xwhr7khkfri" "1909-10-10T07:11:56.078161042Z" "felfri" true "subdevice1"
824567 "9xwhr7khkfri" "1909-10-10T07:11:56.078161042Z" "felfri" false "subdevice2"

Följande JQ-fråga skapar ett separat utdatameddelande för varje underenhetspost i meddelandet och innehåller viss gemensam information från basmeddelandet och den överordnade enheten. Den här frågan plattar utdata och separerar logiska divisioner i dina data som kom som ett enda meddelande:

import "iotc" as iotc;
{
    enqueuedTime: .enqueuedTime,
    deviceId: .device.id,
    parentStatus: .telemetry | iotc::find(.name == "parentStatus").value
} + (
    .telemetry
    | iotc::find(.name == "data").value[]
    | {
        subdeviceId: .id,
        running: .values.running,
        cycleCount: .values.cycleCount
    }
)

JSON-utdata:

{
    "cycleCount": 2315,
    "deviceId": "9xwhr7khkfri",
    "enqueuedTime": "1909-10-10T07:11:56.078161042Z",
    "parentStatus": "healthy",
    "running": true,
    "subdeviceId": "subdevice1"
},
{
    "cycleCount": 824567,
    "deviceId": "9xwhr7khkfri",
    "enqueuedTime": "1909-10-10T07:11:56.078161042Z",
    "parentStatus": "healthy",
    "running": false,
    "subdeviceId": "subdevice2"
}

Scenario 3: Power BI-strömning

Med realtidsströmningsfunktionen i Power BI kan du visa data på en instrumentpanel som uppdateras i realtid med låg svarstid. Mer information finns i Realtidsströmning i Power BI.

Om du vill använda IoT Central med Power BI Streaming konfigurerar du en webhook-export som skickar begärandeorgan i ett visst format. Det här exemplet förutsätter att du har en Power BI Streaming-datauppsättning med följande schema:


  {
    "bloodPressureDiastolic": 161438124,
    "bloodPressureSystolic": -966387879,
    "deviceId": "9xwhr7khkfri",
    "deviceName": "wireless port",
    "heartRate": -633994413,
    "heartRateVariability": -37514094,
    "respiratoryRate": 1582211310,
    "timestamp": "1909-10-10T07:11:56.078161042Z"
  }

Om du vill skapa webhookens exportmål behöver du REST API URL-slutpunkten för din Power BI-strömmande datauppsättning.

I det här scenariot skickar enheten telemetrimeddelanden som ser ut som i följande exempel:

{
  "applicationId": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "enqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "messageSource": "telemetry",
  "telemetry": [
    {
      "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:HeartRate;1",
      "name": "HeartRate",
      "value": -633994413
    },
    {
      "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:RespiratoryRate;1",
      "name": "RespiratoryRate",
      "value": 1582211310
    },
    {
      "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:HeartRateVariability;1",
      "name": "HeartRateVariability",
      "value": -37514094
    },
    {
      "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:BodyTemperature;1",
      "name": "BodyTemperature",
      "value": 5.323322666478241e+307
    },
    {
      "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:FallDetection;1",
      "name": "FallDetection",
      "value": "Earum est nobis at voluptas id qui."
    },
    {
      "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:BloodPressure;1",
      "name": "BloodPressure",
      "value": {
        "Diastolic": 161438124,
        "Systolic": -966387879
      }
    }
  ],
  "device": {
    "id": "9xwhr7khkfri",
    "name": "wireless port",
    "templateId": "dtmi:hpzy1kfcbt2:umua7dplmbd",
    "templateName": "Smart Vitals Patch",
    "properties": {
      "reported": [
        {
          "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_wr:DeviceStatus;1",
          "name": "DeviceStatus",
          "value": "Id optio iste vero et neque sit."
        }
      ]
    },
    "cloudProperties": [],
    "simulated": true,
    "approved": true,
    "blocked": false,
    "provisioned": false
  }
}

Följande JQ-fråga omvandlar indatameddelandet till ett format som är lämpligt för webhooken som ska skickas till Power BI-strömmande datamängd. Det här exemplet innehåller ett filtervillkor för att endast mata ut meddelanden för en specifik enhetsmall. Du kan använda funktionen för dataexportfilter för att filtrera efter enhetsmall:

import "iotc" as iotc;
if .device.templateId == "dtmi:hpzy1kfcbt2:umua7dplmbd" then 
    {
        deviceId: .device.id,
        timestamp: .enqueuedTime,
        deviceName: .device.name,
        bloodPressureSystolic: .telemetry | iotc::find(.name == "BloodPressure").value.Systolic,
        bloodPressureDiastolic: .telemetry | iotc::find(.name == "BloodPressure").value.Diastolic,
        heartRate: .telemetry | iotc::find(.name == "HeartRate").value,
        heartRateVariability: .telemetry | iotc::find(.name == "HeartRateVariability").value,
        respiratoryRate: .telemetry | iotc::find(.name == "RespiratoryRate").value
    }
else
    empty
end

JSON-utdata:

{
  "bloodPressureDiastolic": 161438124,
  "bloodPressureSystolic": -966387879,
  "deviceId": "9xwhr7khkfri",
  "deviceName": "wireless port",
  "heartRate": -633994413,
  "heartRateVariability": -37514094,
  "respiratoryRate": 1582211310,
  "timestamp": "1909-10-10T07:11:56.078161042Z"
}

Scenario 4: Exportera data till Azure Data Explorer och visualisera dem i Power BI

I det här scenariot exporterar du data till Azure Data Explorer och använder sedan en anslutningsapp för att visualisera data i Power BI. Mer information om hur du lägger till ett Azure Data Explorer-kluster och en databas som exportmål finns i Skapa ett Azure Data Explorer-mål.

Det här scenariot använder en Azure Data Explorer-tabell med följande schema:

.create table smartvitalspatch (
  EnqueuedTime:datetime,
  Message:string,
  Application:string,
  Device:string,
  Simulated:boolean,
  Template:string,
  Module:string,
  Component:string,
  Capability:string,
  Value:dynamic
)

I det här scenariot skickar enheten telemetrimeddelanden som ser ut som i följande exempel:

{
    "applicationId": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
    "enqueuedTime": "1909-10-10T07:11:56.078161042Z",
    "messageSource": "telemetry",
    "telemetry": [
        {
            "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:HeartRate;1",
            "name": "HeartRate",
            "value": -633994413
        },
        {
            "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:RespiratoryRate;1",
            "name": "RespiratoryRate",
            "value": 1582211310
        },
        {
            "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:HeartRateVariability;1",
            "name": "HeartRateVariability",
            "value": -37514094
        },
        {
            "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:BodyTemperature;1",
            "name": "BodyTemperature",
            "value": 5.323322666478241e+307
        },
        {
            "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:FallDetection;1",
            "name": "FallDetection",
            "value": "Earum est nobis at voluptas id qui."
        },
        {
            "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_37p:BloodPressure;1",
            "name": "BloodPressure",
            "value": {
                "Diastolic": 161438124,
                "Systolic": -966387879
            }
        }
    ],
    "device": {
        "id": "9xwhr7khkfri",
        "name": "wireless port",
        "templateId": "dtmi:hpzy1kfcbt2:umua7dplmbd",
        "templateName": "Smart Vitals Patch",
        "properties": {
            "reported": [
                {
                    "id": "dtmi:smartVitalsPatch:Smart_Vitals_Patch_wr:DeviceStatus;1",
                    "name": "DeviceStatus",
                    "value": "Id optio iste vero et neque sit."
                }
            ]
        },
        "cloudProperties": [],
        "simulated": true,
        "approved": true,
        "blocked": false,
        "provisioned": false
    }
}

Följande JQ-fråga omvandlar indatameddelandet till ett separat utdatameddelande för varje telemetrivärde. Den här omvandlingen genererar utdata som matchar tabellschemat i Azure Data Explorer. Omvandlingen använder ett schema för entity-attribute-value där varje rad innehåller ett enda telemetrivärde och namnet på telemetrin är ett värde i en separat kolumn på samma rad:

. as $in | .telemetry[] | {
  EnqueuedTime: $in.enqueuedTime,
  Message: $in.messageId,
  Application: $in.applicationId,
  Device: $in.device.id,
  Simulated: $in.device.simulated,
  Template: ($in.device.templateName // ""),
  Module: ($in.module // ""),
  Component: ($in.component // ""),
  Capability: .name,
  Value: .value
}

JSON-utdata:

{
  "Application": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "Capability": "HeartRate",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": -633994413
},
{
  "Application": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "Capability": "RespiratoryRate",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": 1582211310
},
{
  "Application": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "Capability": "HeartRateVariability",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": -37514094
},
{
  "Application": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "Capability": "BodyTemperature",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": 5.323322666478241e+307
},
{
  "Application": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "Capability": "FallDetection",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": "Earum est nobis at voluptas id qui."
},
{
  "Application": "570c2d7b-d72e-4ad1-aaf4-ad9b727daa47",
  "Capability": "BloodPressure",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": {
      "Diastolic": 161438124,
      "Systolic": -966387879
  }
}

Utdata exporteras till ditt Azure Data Explorer-kluster. Utför följande steg för att visualisera exporterade data i Power BI:

  1. Installera Power BI-programmet. Du kan ladda ned Power BI-programmet från Gå från data till insikt till åtgärd med Power BI Desktop.
  2. Ladda ned filen Power BI Desktop IoT Central ADX Anslut or.pbit från GitHub.
  3. Använd Power BI Desktop-appen för att öppna filen IoT Central ADX Anslut or.pbit som du laddade ned i föregående steg. När du uppmanas till det anger du den Azure Data Explorer-kluster-, databas- och tabellinformation som du antecknade tidigare.

Nu kan du visualisera data i Power BI:

Screenshot of Power BI report that shows data from IoT Central.

Nästa steg

Nu när du vet hur du transformerar data i IoT Central är ett föreslaget nästa steg att lära dig hur du använder analys i IoT Central.