Share via

Przekształcanie danych wewnątrz aplikacji usługi IoT Central do eksportowania

  • Artykuł

Urządzenia IoT wysyłają dane w różnych formatach. Aby korzystać z danych urządzenia w rozwiązaniu IoT, może być konieczne przekształcenie danych urządzenia przed ich wyeksportowanie do innych usług.

W tym artykule pokazano, jak przekształcić dane urządzenia w ramach definicji eksportu danych w aplikacji usługi IoT Central.

Przekształcenia w definicji eksportu danych usługi IoT Central umożliwiają manipulowanie formatem i strukturą danych urządzenia przed ich wyeksportowanie do miejsca docelowego. Można określić przekształcenie dla każdego miejsca docelowego w definicji eksportu. Każdy komunikat przechodzi przez przekształcenie w celu utworzenia rekordu wyjściowego wyeksportowanego do miejsca docelowego.

Przekształcanie służy do zmiany struktury ładunków JSON, zmieniania nazw pól, filtrowania pól i uruchamiania prostych obliczeń dotyczących wartości telemetrii. Na przykład użyj przekształcenia, aby przekonwertować komunikaty na format tabelaryczny zgodny ze schematem miejsca docelowego, takiego jak tabela usługi Azure Data Explorer.

W poniższym filmie wideo przedstawiono przekształcenia danych usługi IoT Central:

Dodawanie przekształcenia

Aby dodać przekształcenie dla miejsca docelowego w eksporcie danych, wybierz pozycję + Przekształć , jak pokazano na poniższym zrzucie ekranu:

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

Panel Przekształcanie danych umożliwia określenie przekształcenia. W 1. Dodaj sekcję komunikatu wejściowego. Możesz wprowadzić przykładowy komunikat, który ma zostać przekazany przez przekształcenie. Możesz również wygenerować przykładowy komunikat, wybierając szablon urządzenia. W 2. Utwórz sekcję zapytania przekształcenia, możesz wprowadzić zapytanie, które przekształca komunikat wejściowy. 3. Sekcja podglądu komunikatów wyjściowych pokazuje wynik przekształcenia:

Screenshot of transformation editor in IoT Central.

Napiwek

Jeśli nie znasz formatu komunikatu wejściowego, użyj . go jako zapytania, aby wyeksportować komunikat w taki sposób, jak do miejsca docelowego, takiego jak element webhook. Następnie wklej komunikat odebrany przez element webhook do 1. Dodaj komunikat wejściowy. Następnie skompiluj zapytanie przekształcenia, aby przetworzyć ten komunikat w wymaganym formacie wyjściowym.

Tworzenie zapytania przekształcenia

Aparat przekształcania używa procesora JQ JSON typu open source do zmiany struktury i formatowania ładunków JSON. Aby określić przekształcenie, należy napisać zapytanie JQ, które może używać wbudowanych filtrów, funkcji i funkcji JQ. Aby zapoznać się z przykładami zapytań, zobacz Przykładowe zapytania przekształcania. Aby dowiedzieć się więcej na temat pisania zapytań JQ, zobacz podręcznik JQ.

Struktura komunikatów przed przekształceniem

Możesz wyeksportować następujące strumienie danych z usługi IoT Central: dane telemetryczne, zmiany właściwości, zdarzenia łączności urządzeń, zdarzenia cyklu życia urządzenia i zdarzenia cyklu życia szablonu urządzenia. Każdy typ danych ma określoną strukturę, która zawiera informacje, takie jak wartości telemetrii, informacje o aplikacji, metadane urządzenia i wartości właściwości.

Poniższy przykład przedstawia kształt komunikatu telemetrii. Wszystkie te dane są dostępne dla transformacji. Struktura komunikatu jest podobna dla innych typów komunikatów, ale istnieją pewne pola specyficzne dla typu. Możesz użyć funkcji Dodawanie komunikatu wejściowego, aby wygenerować przykładowy komunikat na podstawie szablonu urządzenia w aplikacji.

{
  "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"
}

Napiwek

Użyj funkcji Dodaj komunikat wejściowy w interfejsie użytkownika aplikacji usługi IoT Central, aby wyświetlić przykładowe struktury komunikatów dla innych typów eksportu danych, takich jak zmiany właściwości.

Przykładowe zapytania przekształcania

W poniższych przykładach zapytań użyto komunikatu telemetrii pokazanego w poprzedniej sekcji.

Przykład 1: Następujące zapytanie JQ zwraca każdy fragment danych telemetrycznych z komunikatu wejściowego jako oddzielny komunikat wyjściowy:

.telemetry[]

Dane wyjściowe JSON:

{
  "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
}

Napiwek

Aby zmienić dane wyjściowe na pojedynczy komunikat z tablicą typów telemetrii, użyj zapytania .telemetry.

Przykład 2: Następujące zapytanie JQ konwertuje tablicę telemetrii wejściowej na obiekt z nazwami telemetrii jako kluczami:

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

Dane wyjściowe JSON:

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

Przykład 3: Następujące zapytanie JQ znajduje wartość telemetrii RangeOfMotion i konwertuje ją ze stopni na radiany przy użyciu formuły rad = degree * pi / 180. To zapytanie pokazuje również sposób importowania i używania modułu iotc :

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

Dane wyjściowe JSON:

{
  "rangeOfMotion": 1.9198621771937625
}

Przykład 4: Aby manipulować komunikatem wejściowym w formacie tabelarycznym, można mapować każdy wyeksportowany komunikat na co najmniej jeden wiersz. Dane wyjściowe wiersza są logicznie reprezentowane jako obiekt JSON, w którym nazwa kolumny jest kluczem, a wartość kolumny jest wartością:

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

Napiwek

Podczas eksportowania do usługi Azure Data Explorer użyj formatu tabelarycznego.

Poniższe zapytanie JQ zapisuje wiersze w tabeli, która przechowuje dane telemetryczne rangeOfMotion na różnych urządzeniach. Zapytanie mapuje identyfikator urządzenia, czas w kolejce i zakres ruchu do tabeli z następującymi kolumnami:

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

Dane wyjściowe w formacie JSON:

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

Moduł usługi IoT Central

Moduł JQ to kolekcja funkcji niestandardowych. W ramach zapytania przekształcenia możesz zaimportować wbudowany moduł specyficzny dla usługi IoT Central zawierający funkcje, aby ułatwić pisanie zapytań. Aby zaimportować moduł usługi IoT Central, użyj następującej dyrektywy:

import "iotc" as iotc;

Moduł usługi IoT Central zawiera następujące funkcje:

find(expression): Funkcja find umożliwia znalezienie określonego elementu tablicy, takiego jak wartość telemetrii lub wpis właściwości w ładunku. Dane wejściowe funkcji to tablica, a parametr definiuje filtr JQ do uruchamiania względem każdego elementu w tablicy. Funkcja zwraca każdy element tablicy, w którym filtr daje wartość true:

Aby na przykład znaleźć określoną wartość telemetrii o nazwie RangeOfMotion:

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

Scenariusze

Poniższe scenariusze używają funkcji przekształcania, aby dostosować format danych urządzenia dla określonego miejsca docelowego.

Scenariusz 1. Eksportowanie danych urządzenia do usługi Azure Data Explorer

W tym scenariuszu dane urządzenia są przekształcane w taki sposób, aby odpowiadały stałemu schematowi w usłudze Azure Data Explorer, gdzie każda wartość telemetrii jest wyświetlana jako kolumna w tabeli, a każdy wiersz reprezentuje jeden komunikat. Przykład:

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

Aby wyeksportować dane zgodne z tą tabelą, każdy wyeksportowany komunikat musi wyglądać podobnie do następującego obiektu. Obiekt reprezentuje pojedynczy wiersz, w którym klucze są nazwami kolumn, a wartości są wartością do umieszczenia w każdej kolumnie:

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

W tym scenariuszu urządzenie wysyła wartości telemetryczne t1, t2i t3 w komunikacie wejściowym, który wygląda jak w poniższym przykładzie:

{
  "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
  }
}

Następujące zapytanie JQ zwraca T1wartości , T2 i telemetrii, Timestamp i T3deviceId jako komunikat z parami klucz-wartość pasujące do schematu tabeli usługi 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,
}

Dane wyjściowe JSON:

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

Aby dowiedzieć się więcej na temat dodawania klastra i bazy danych usługi Azure Data Explorer jako miejsca docelowego eksportu, zobacz Tworzenie miejsca docelowego usługi Azure Data Explorer.

Scenariusz 2. Podział tablicy telemetrii

W tym scenariuszu urządzenie wysyła następującą tablicę danych telemetrycznych w jednym komunikacie:

{
  "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
  }
}

Chcesz przekształcić te dane urządzenia w taki sposób, aby odpowiadały następującemu schematowi tabeli:

cycleCount deviceId enqueuedTime parentStatus uruchomiono subdeviceId
2315 "9xwhr7khkfri" "1909-10-10T07:11:56.078161042Z" "zdrowa" true "subdevice1"
824567 "9xwhr7khkfri" "1909-10-10T07:11:56.078161042Z" "zdrowa" fałsz "subdevice2"

Poniższe zapytanie JQ tworzy oddzielny komunikat wyjściowy dla każdego wpisu urządzenia podrzędnego w komunikacie i zawiera niektóre typowe informacje z podstawowego komunikatu i urządzenia nadrzędnego. To zapytanie spłaszcza dane wyjściowe i oddziela podziały logiczne w danych, które dotarły jako pojedynczy komunikat:

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

Dane wyjściowe JSON:

{
    "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"
}

Scenariusz 3. Przesyłanie strumieniowe w usłudze Power BI

Funkcja przesyłania strumieniowego w czasie rzeczywistym w usłudze Power BI umożliwia wyświetlanie danych na pulpicie nawigacyjnym, który jest aktualizowany w czasie rzeczywistym z małym opóźnieniem. Aby dowiedzieć się więcej, zobacz Przesyłanie strumieniowe w czasie rzeczywistym w usłudze Power BI.

Aby użyć usługi IoT Central z usługą Power BI Streaming, skonfiguruj eksport elementu webhook, który wysyła treść żądań w określonym formacie. W tym przykładzie założono, że masz zestaw danych przesyłania strumieniowego usługi Power BI z następującym schematem:


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

Aby utworzyć miejsce docelowe eksportu elementu webhook, potrzebny jest punkt końcowy adresu URL interfejsu API REST dla zestawu danych przesyłania strumieniowego usługi Power BI.

W tym scenariuszu urządzenie wysyła komunikaty telemetryczne, które wyglądają jak w poniższym przykładzie:

{
  "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
  }
}

Następujące zapytanie JQ przekształca komunikat wejściowy w format odpowiedni dla elementu webhook do wysyłania do zestawu danych przesyłania strumieniowego usługi Power BI. Ten przykład zawiera warunek filtru umożliwiający wyświetlanie tylko komunikatów wyjściowych dla określonego szablonu urządzenia. Możesz użyć funkcji filtru eksportu danych do filtrowania według szablonu urządzenia:

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

Dane wyjściowe JSON:

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

Scenariusz 4. Eksportowanie danych do usługi Azure Data Explorer i wizualizowanie ich w usłudze Power BI

W tym scenariuszu dane są eksportowane do usługi Azure Data Explorer, a następnie używane przez łącznik do wizualizacji danych w usłudze Power BI. Aby dowiedzieć się więcej na temat dodawania klastra i bazy danych usługi Azure Data Explorer jako miejsca docelowego eksportu, zobacz Tworzenie miejsca docelowego usługi Azure Data Explorer.

W tym scenariuszu użyto tabeli usługi Azure Data Explorer z następującym schematem:

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

W tym scenariuszu urządzenie wysyła komunikaty telemetryczne, które wyglądają jak w poniższym przykładzie:

{
    "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
    }
}

Następujące zapytanie JQ przekształca komunikat wejściowy w oddzielny komunikat wyjściowy dla każdej wartości telemetrii. Ta transformacja generuje dane wyjściowe zgodne ze schematem tabeli usługi Azure Data Explorer. Przekształcenie używa schematu entity-attribute-value, w którym każdy wiersz zawiera pojedynczą wartość telemetrii, a nazwa telemetrii jest wartością w oddzielnej kolumnie w tym samym wierszu:

. 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
}

Dane wyjściowe JSON:

{
  "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
  }
}

Dane wyjściowe są eksportowane do klastra usługi Azure Data Explorer. Aby zwizualizować wyeksportowane dane w usłudze Power BI, wykonaj następujące kroki:

  1. Zainstaluj aplikację usługi Power BI. Aplikację power BI klasyczną można pobrać z języka Go z danych, aby uzyskać szczegółowe informacje w celu wykonania akcji za pomocą programu Power BI Desktop.
  2. Pobierz plik ADX usługi ADX usługi IoT Central usługi IoT Central Połączenie or.pbit z usługi GitHub.
  3. Użyj aplikacji Power BI Desktop, aby otworzyć plik ADX usługi IoT Central Połączenie or.pbit pobrany w poprzednim kroku. Po wyświetleniu monitu wprowadź informacje o klastrze, bazie danych i tabeli usługi Azure Data Explorer zanotowane wcześniej.

Teraz możesz wizualizować dane w usłudze Power BI:

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

Następne kroki

Teraz, gdy wiesz już, jak przekształcać dane w usłudze IoT Central, sugerowanym następnym krokiem jest poznanie sposobu używania analizy w usłudze IoT Central.