Trasformare i dati all'interno dell'applicazione IoT Central per l'esportazione

I dispositivi IoT inviano dati in vari formati. Per usare i dati del dispositivo nella soluzione IoT, potrebbe essere necessario trasformare i dati del dispositivo prima di esportarli in altri servizi.

Questo articolo illustra come trasformare i dati del dispositivo come parte di una definizione di esportazione dei dati in un'applicazione IoT Central.

Le trasformazioni in una definizione di esportazione dei dati di IoT Central consentono di modificare il formato e la struttura dei dati del dispositivo prima di esportarli in una destinazione. Nell'ambito di una definizione di esportazione, è possibile specificare una trasformazione per ogni specifica destinazione. Ogni messaggio passa attraverso la trasformazione per creare un record di output da esportare nella destinazione.

Usare le trasformazioni per ristrutturare i payload JSON, rinominare i campi, filtrare i campi ed eseguire semplici calcoli sui valori dei dati di telemetria. È ad esempio possibile usare una trasformazione per convertire i messaggi in un formato tabulare corrispondente allo schema di una certa destinazione, quale una tabella di Esplora dati di Azure.

Il video seguente presenta le trasformazioni dei dati di IoT Central:

Aggiungere una trasformazione

Per aggiungere una trasformazione per una destinazione nella definizione di esportazione dei dati, selezionare + Trasforma come illustrato nello screenshot seguente:

Il pannello Trasformazione dati consente di specificare la trasformazione. In 1. Aggiungere la sezione del messaggio di input, è possibile immettere un messaggio di esempio che si vuole passare attraverso la trasformazione. È anche possibile generare un messaggio di esempio selezionando un modello di dispositivo. Nel 2. La sezione Query di trasformazione compilazione consente di immettere la query che trasforma il messaggio di input. Il 3. La sezione Anteprima dei messaggi di output mostra il risultato della trasformazione:

Creare una query di trasformazione

Il motore di trasformazione usa il processore JSON JQ open source per ristrutturare e formattare i payload JSON. Per specificare una trasformazione, si scrive una query JQ, che può usare i filtri, le funzioni e le funzionalità predefiniti di JQ. Per alcuni esempi di query, vedere Query di trasformazione di esempio. Per altre informazioni sulla scrittura di query JQ, vedere il manuale JQ.

Struttura dei messaggi di pre-trasformazione

È possibile esportare i flussi di dati seguenti da IoT Central: telemetria, modifiche alle proprietà, eventi di connettività dei dispositivi, eventi del ciclo di vita del dispositivo ed eventi del ciclo di vita del modello di dispositivo. Ogni tipo di dati ha una struttura specifica che include informazioni quali valori di telemetria, informazioni sull'applicazione, metadati del dispositivo e valori delle proprietà.

Nell'esempio seguente viene illustrata la forma del messaggio di telemetria. Tutti questi dati sono disponibili per la trasformazione. La struttura del messaggio è simile per altri tipi di messaggio, ma esistono alcuni campi specifici del tipo. È possibile usare la funzionalità Aggiungi messaggio di input per generare un messaggio di esempio basato su un modello di dispositivo nell'applicazione.

{
  "applicationId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "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"
}

Query di trasformazione di esempio

Gli esempi di query seguenti usano il messaggio di telemetria illustrato nella sezione precedente.

Esempio 1: la query JQ seguente restituisce ogni parte di telemetria dal messaggio di input come messaggio di output separato:

.telemetry[]

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

Esempio 2: la query JQ seguente converte la matrice di telemetria di input in un oggetto con nomi di telemetria come chiavi:

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

Output JSON:

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

Esempio 3: la query JQ seguente trova il valore di telemetria RangeOfMotion e lo converte da gradi a radianti usando la formula rad = degree * pi / 180. Questa query illustra anche come importare e usare il iotc modulo:

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

Output JSON:

{
  "rangeOfMotion": 1.9198621771937625
}

Esempio 4: per modificare il messaggio di input in un formato tabulare, è possibile eseguire il mapping di ogni messaggio esportato in una o più righe. L'output di riga è rappresentato logicamente come oggetto JSON in cui il nome della colonna è la chiave e il valore della colonna è il valore:

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

La query JQ seguente scrive righe in una tabella in cui sono archiviati i dati di telemetria rangeOfMotion in dispositivi diversi. La query esegue il mapping dell'ID dispositivo, del tempo accodato e dell'intervallo di movimento in una tabella con queste colonne:

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

Output in formato JSON:

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

Modulo IoT Central

Un modulo JQ è una raccolta di funzioni personalizzate. Come parte della query di trasformazione, è possibile importare un modulo specifico di IoT Central predefinito che contiene funzioni per semplificare la scrittura delle query. Per importare il modulo IoT Central, usare la direttiva seguente:

import "iotc" as iotc;

Il modulo IoT Central include le funzioni seguenti:

find(expression): la find funzione consente di trovare un elemento di matrice specifico, ad esempio il valore di telemetria o la voce della proprietà nel payload. L'input della funzione è una matrice e il parametro definisce un filtro JQ da eseguire su ogni elemento della matrice. La funzione restituisce ogni elemento della matrice in cui il filtro restituisce true:

Ad esempio, per trovare un valore di telemetria specifico denominato RangeOfMotion:

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

Scenari

Gli scenari seguenti usano la funzionalità di trasformazione per personalizzare il formato dei dati del dispositivo per una destinazione specifica.

Scenario 1: Esportare i dati dei dispositivi in Azure Esplora dati

In questo scenario si trasformano i dati del dispositivo in modo che corrispondano allo schema fisso in Azure Esplora dati, in cui ogni valore di telemetria viene visualizzato come colonna nella tabella e ogni riga rappresenta un singolo messaggio. Ad esempio:

Per esportare dati compatibili con questa tabella, ogni messaggio esportato deve essere simile all'oggetto seguente. L'oggetto rappresenta una singola riga, in cui le chiavi sono nomi di colonna e i valori sono il valore da inserire in ogni colonna:

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

In questo scenario, il dispositivo invia i t1valori di telemetria , t2e t3 in un messaggio di input simile all'esempio seguente:

{
  "applicationId": "11112222-bbbb-3333-cccc-4444dddd5555",
  "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
  }
}

La query JQ seguente restituisce i T1valori Timestamp di telemetria T2 e T3 e come deviceId messaggio con coppie chiave-valore corrispondenti allo schema della tabella di Azure Esplora dati:

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

Output JSON:

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

Per altre informazioni su come aggiungere un cluster e un database di Azure Esplora dati come destinazione di esportazione, vedere Creare una destinazione di Azure Esplora dati.

Scenario 2: Suddividere una matrice di dati di telemetria

In questo scenario, il dispositivo invia la matrice di dati di telemetria seguente in un messaggio:

{
  "applicationId": "22223333-cccc-4444-dddd-5555eeee6666",
  "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
  }
}

Si vuole trasformare i dati del dispositivo in modo che corrispondano allo schema di tabella seguente:

La query JQ seguente crea un messaggio di output separato per ogni voce del sottodispositivo nel messaggio e include alcune informazioni comuni del messaggio di base e del dispositivo padre. Questa query rende flat l'output e separa le divisioni logiche nei dati ricevuti come singolo messaggio:

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

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

Scenario 3: Streaming di Power BI

La funzionalità di streaming in tempo reale di Power BI consente di visualizzare i dati in un dashboard che viene aggiornato in tempo reale con bassa latenza. Per altre informazioni, vedere Streaming in tempo reale in Power BI.

Per usare IoT Central con Power BI Streaming, configurare un'esportazione di webhook che invia corpi di richiesta in un formato specifico. Questo esempio presuppone che si disponga di un set di dati di Power BI Streaming con lo schema seguente:

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

Per creare la destinazione di esportazione del webhook, è necessario l'endpoint dell'URL dell'API REST per il set di dati di streaming di Power BI.

In questo scenario, il dispositivo invia messaggi di telemetria simili all'esempio seguente:

{
  "applicationId": "22223333-cccc-4444-dddd-5555eeee6666",
  "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
  }
}

La query JQ seguente trasforma il messaggio di input in un formato adatto al webhook da inviare al set di dati di streaming di Power BI. Questo esempio include una condizione di filtro per restituire solo i messaggi per un modello di dispositivo specifico. È possibile usare la funzionalità di filtro di esportazione dei dati per filtrare in base al modello di dispositivo:

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

Output JSON:

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

Scenario 4: Esportare i dati in Azure Esplora dati e visualizzarli in Power BI

In questo scenario si esportano i dati in Azure Esplora dati e quindi si usa un connettore per visualizzare i dati in Power BI. Per altre informazioni su come aggiungere un cluster e un database di Azure Esplora dati come destinazione di esportazione, vedere Creare una destinazione di Azure Esplora dati.

Questo scenario usa una tabella Esplora dati di Azure con lo schema seguente:

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

In questo scenario, il dispositivo invia messaggi di telemetria simili all'esempio seguente:

{
    "applicationId": "22223333-cccc-4444-dddd-5555eeee6666",
    "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
    }
}

La query JQ seguente trasforma il messaggio di input in un messaggio di output separato per ogni valore di telemetria. Questa trasformazione produce un output che corrisponde allo schema di tabella di Azure Esplora dati. La trasformazione usa uno schema entity-attribute-value in cui ogni riga contiene un singolo valore di telemetria e il nome dei dati di telemetria è un valore in una colonna separata nella stessa riga:

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

Output JSON:

{
  "Application": "22223333-cccc-4444-dddd-5555eeee6666",
  "Capability": "HeartRate",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": -633994413
},
{
  "Application": "22223333-cccc-4444-dddd-5555eeee6666",
  "Capability": "RespiratoryRate",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": 1582211310
},
{
  "Application": "22223333-cccc-4444-dddd-5555eeee6666",
  "Capability": "HeartRateVariability",
  "Component": "",
  "Device": "9xwhr7khkfri",
  "EnqueuedTime": "1909-10-10T07:11:56.078161042Z",
  "Message": null,
  "Module": "",
  "Simulated": true,
  "Template": "Smart Vitals Patch",
  "Value": -37514094
},
{
  "Application": "22223333-cccc-4444-dddd-5555eeee6666",
  "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": "22223333-cccc-4444-dddd-5555eeee6666",
  "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": "22223333-cccc-4444-dddd-5555eeee6666",
  "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
  }
}

I dati di output vengono esportati nel cluster Esplora dati di Azure. Per visualizzare i dati esportati in Power BI, seguire questa procedura:

1. Installare l'applicazione Power BI. È possibile scaricare l'applicazione Power BI desktop da Vai dai dati alle informazioni dettagliate per l'azione con Power BI Desktop.
2. Scaricare il file Power BI Desktop IoT Central ADX Connector.pbit da GitHub.
3. Usare l'app Power BI Desktop per aprire il file IoT Central ADX Connector.pbit scaricato nel passaggio precedente. Quando richiesto, immettere le informazioni del cluster, del database e della tabella di Azure Esplora dati annotato in precedenza.

È ora possibile visualizzare i dati in Power BI:

Passaggi successivi

Ora che si è appreso come trasformare i dati in IoT Central, un passaggio successivo consigliato consiste nell'apprendere come usare l'analisi in IoT Central.