Utvecklarguide för IoT Plug and Play-tjänsten

Med IoT Plug and Play kan du skapa IoT-enheter som annonserar sina funktioner till Azure IoT-program. IoT Plug and Play-enheter kräver inte manuell konfiguration när en kund ansluter dem till IoT Plug- och Play-aktiverade program.

Med IoT Plug and Play kan du använda enheter som har meddelat sitt modell-ID med din IoT-hubb. Du kan till exempel komma åt egenskaperna och kommandona för en enhet direkt.

Om du använder IoT Central kan du använda IoT Central UI och REST API för att interagera med IoT Plug and Play-enheter som är anslutna till ditt program.

Tjänst-SDK:er

Använd Azure IoT-tjänstens SDK:er i din lösning för att interagera med enheter och moduler. Du kan till exempel använda tjänst-SDK:erna för att läsa och uppdatera tvillingegenskaper och anropa kommandon. Språk som stöds är C#, Java, Node.js och Python.

Azure IoT-tjänstens SDK:er innehåller kod som underlättar skapandet av program som interagerar direkt med IoT Hub för att hantera enheter och säkerhet.

Plattform	Paket	Kodlagringsplats	Exempel	Referens
.NET	NuGet	GitHub	Exempel	Referens
Java	Maven	GitHub	Exempel	Referens
Nod	npm	GitHub	Exempel	Referens
Python	Pip	GitHub	Exempel	Referens

Med tjänst-SDK:er kan du komma åt enhetsinformation från en lösningskomponent, till exempel ett skrivbords- eller webbprogram. Tjänst-SDK:erna innehåller två namnområden och objektmodeller som du kan använda för att hämta modell-ID:t:

• Iot Hub-tjänstklient. Den här tjänsten exponerar modell-ID:t som en enhetstvillingeegenskap.

• Digital Twins-klient. Det nya Digital Twins-API:et fungerar på DTDL-modellkonstruktioner (Digital Twins Definition Language), till exempel komponenter, egenskaper och kommandon. Api:erna för Digital Twin gör det enklare för lösningsbyggare att skapa IoT Plug and Play-lösningar.

Följande resurser är också tillgängliga:

• Referensdokumentation för .NET SDK
• Tjänstklientexempel
• Digital Twins-exempel

IoT Hub-tjänstklientexempel

Det här avsnittet visar C#-exempel med IoT Hub-tjänstklienten och registrymanager - och ServiceClient-klasserna . Du använder klassen RegistryManager för att interagera med enhetstillståndet med hjälp av enhetstvillingar. Du kan också använda klassen RegistryManager för att köra frågor mot enhetsregistreringar i din IoT Hub. Du använder klassen ServiceClient för att anropa kommandon på enheten. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar. I kodfragmenten innehåller variabeln deviceTwinId enhets-ID för IoT Plug and Play-enheten som är registrerad med din IoT-hubb.

Hämta enhetstvillingen och modell-ID:t

Så här hämtar du enhetstvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

RegistryManager registryManager = RegistryManager.CreateFromConnectionString(parameters.HubConnectionString);

Twin twin = await registryManager.GetTwinAsync(deviceTwinId);
Console.WriteLine($"Device twin: \n{JsonConvert.SerializeObject(twin, Formatting.Indented)}");
Console.WriteLine($"Model ID: {twin.ModelId}.");

Uppdatera enhetstvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Exemplet visar hur du behöver hämta tvillingens ETag innan du uppdaterar den. Egenskapen definieras i enhetens standardkomponent:

Twin twin = await registryManager.GetTwinAsync(deviceTwinId);

int desiredTargetTemperature = 60;

// Update the twin
var twinPatch = new Twin();
twinPatch.Properties.Desired["targetTemperature"] = desiredTargetTemperature;

Console.WriteLine($"Update the targetTemperature property to {desiredTargetTemperature}.");

await registryManager.UpdateTwinAsync(deviceTwinId, twinPatch, twin.ETag);

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Exemplet visar hur du behöver hämta tvillingens ETag innan du uppdaterar den. Egenskapen definieras i Thermostat1-komponenten :

Twin twin = await registryManager.GetTwinAsync(deviceTwinId);

int desiredTargetTemperature = 60;

var twinPatch = CreatePropertyPatch("targetTemperature", desiredTargetTemperature, "thermostat1");

await registryManager.UpdateTwinAsync(deviceTwinId, twinPatch, twin.ETag);

// ...

private static Twin CreatePropertyPatch(string propertyName, object propertyValue, string componentName)
{
    var twinPatch = new Twin();
    twinPatch.Properties.Desired[componentName] = new
    {
        __t = "c"
    };
    twinPatch.Properties.Desired[componentName][propertyName] = JsonConvert.SerializeObject(propertyValue);
    return twinPatch;
}

För en egenskap i en komponent ser egenskapskorrigeringen ut som följande exempel:

{
"sampleComponentName":
  {
    "__t": "c",
    "samplePropertyName": 20
  }
}

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

ServiceClient serviceClient = ServiceClient.CreateFromConnectionString(parameters.HubConnectionString);

var commandInvocation = new CloudToDeviceMethod("getMaxMinReport") { ResponseTimeout = TimeSpan.FromSeconds(30) };

// Set command payload
DateTimeOffset since = DateTimeOffset.Now.Subtract(TimeSpan.FromMinutes(2));
string componentCommandPayload = JsonConvert.SerializeObject(since);
commandInvocation.SetPayloadJson(componentCommandPayload);

try
{
  CloudToDeviceMethodResult result = await serviceClient.InvokeDeviceMethodAsync(deviceTwinId, commandInvocation);

  Console.WriteLine($"Command getMaxMinReport was invoked." +
      $"\nDevice returned status: {result.Status}. \nReport: {result.GetPayloadAsJson()}");
}
catch (DeviceNotFoundException)
{
    Console.WriteLine($"Unable to execute command getMaxMinReport on {deviceTwinId}.";
}

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i Thermostat1-komponenten :

// Create command name to invoke for component. The command is formatted as <component name>*<command name>
string commandToInvoke = "thermostat1*getMaxMinReport";
var commandInvocation = new CloudToDeviceMethod(commandToInvoke) { ResponseTimeout = TimeSpan.FromSeconds(30) };

// Set command payload
DateTimeOffset since = DateTimeOffset.Now.Subtract(TimeSpan.FromMinutes(2));
string componentCommandPayload = JsonConvert.SerializeObject(since);
commandInvocation.SetPayloadJson(componentCommandPayload);

try
{
    CloudToDeviceMethodResult result = await serviceClient.InvokeDeviceMethodAsync(deviceTwinId, commandInvocation);
    Console.WriteLine($"Command getMaxMinReport was invoked on component thermostat1." +
        $"\nDevice returned status: {result.Status}. \nReport: {result.GetPayloadAsJson()}");
}
catch (DeviceNotFoundException)
{
    Console.WriteLine("Unable to execute command getMaxMinReport on component thermostat1.");
}

Exempel på digitala IoT Hub-tvillingar

Du använder klassen DigitalTwinClient för att interagera med enhetstillståndet med hjälp av digitala tvillingar. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar.

Det här avsnittet visar C#-exempel med hjälp av Digital Twins-API:et. Följande kodfragment använder följande klasser för att representera den digitala tvillingen för termostat- och temperaturstyrenhetsenheterna:

using Microsoft.Azure.Devices.Serialization;
using Newtonsoft.Json;
using System;

namespace Microsoft.Azure.Devices.Samples
{
  internal class ThermostatTwin : BasicDigitalTwin
  {
    [JsonProperty("$metadata")]
    public new ThermostatMetadata Metadata { get; set; }

    [JsonProperty("maxTempSinceLastReboot")]
    public double? MaxTempSinceLastReboot { get; set; }

    [JsonProperty("targetTemperature")]
    public double? TargetTemperature { get; set; }
  }

  internal class ThermostatMetadata : DigitalTwinMetadata
  {
    [JsonProperty("maxTempSinceLastReboot")]
    public ReportedPropertyMetadata MaxTempSinceLastReboot { get; set; }

    [JsonProperty("targetTemperature")]
    public WritableProperty TargetTemperature { get; set; }
  }

  internal class ReportedPropertyMetadata
  {
    [JsonProperty("lastUpdateTime")]
    public DateTimeOffset LastUpdateTime { get; set; }
  }

  internal class TemperatureControllerTwin : BasicDigitalTwin
  {
    [JsonProperty("$metadata")]
    public new TemperatureControllerMetadata Metadata { get; set; }

    [JsonProperty("serialNumber")]
    public string SerialNumber { get; set; }

    [JsonProperty("thermostat1")]
    public ThermostatTwin Thermostat1 { get; set; }

    [JsonProperty("thermostat2")]
    public ThermostatTwin Thermostat2 { get; set; }
  }

  internal class TemperatureControllerMetadata : DigitalTwinMetadata
  {
    [JsonProperty("serialNumber")]
    public ReportedPropertyMetadata SerialNumber { get; set; }

    [JsonProperty("thermostat1")]
    public WritableProperty Thermostat1 { get; set; }

    [JsonProperty("thermostat2")]
    public WritableProperty Thermostat2 { get; set; }
  }
}

Variabeln digitalTwinId innehåller enhets-ID för IoT Plug and Play-enheten som registrerats med din IoT-hubb.

Hämta den digitala tvillingen och modell-ID:t

Så här hämtar du den digitala tvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

DigitalTwinClient digitalTwinClient = DigitalTwinClient.CreateFromConnectionString(parameters.HubConnectionString);
HttpOperationResponse<ThermostatTwin, DigitalTwinGetHeaders> getDigitalTwinResponse = await digitalTwinClient
    .GetDigitalTwinAsync<ThermostatTwin>(digitalTwinId);
ThermostatTwin thermostatTwin = getDigitalTwinResponse.Body;
Console.WriteLine($"Model ID: {thermostatTwin.Metadata.ModelId}.");
Console.WriteLine($"Digital Twin: \n{JsonConvert.SerializeObject(thermostatTwin, Formatting.Indented)}");

Uppdatera digital tvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Egenskapen definieras i enhetens standardkomponent:

var updateOperation = new UpdateOperationsUtility();

int desiredTargetTemperature = 60;

// Get the current value of the targetTemperature property
HttpOperationResponse<ThermostatTwin, DigitalTwinGetHeaders> getDigitalTwinResponse = await digitalTwinClient
    .GetDigitalTwinAsync<ThermostatTwin>(digitalTwinId);
double? currentTargetTemperature = getDigitalTwinResponse.Body.TargetTemperature;

// Has the targetTemperature property previously been set?
if (currentTargetTemperature != null)
{
  // Update the existing property
  // Prepend the property path with a '/'
  updateOperation.AppendReplacePropertyOp($"/targetTemperature",   desiredTargetTemperature);
}
else
{
  // Add a new property
  // Prepend the property path with a '/'
  updateOperation.AppendAddPropertyOp($"/targetTemperature", desiredTargetTemperature);
}

// Update the targetTemperature property on the digital twin
HttpOperationHeaderResponse<DigitalTwinUpdateHeaders> updateDigitalTwinResponse = await digitalTwinClient
    .UpdateDigitalTwinAsync(digitalTwinId, updateOperation.Serialize());

Console.WriteLine($"Update {digitalTwinId} digital twin response: {updateDigitalTwinResponse.Response.StatusCode}.");

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Egenskapen definieras i Thermostat1-komponenten :

int desiredTargetTemperature = 60;

var updateOperation = new UpdateOperationsUtility();

// Look at when the property was updated and what was it set to.
HttpOperationResponse<TemperatureControllerTwin, DigitalTwinGetHeaders> getDigitalTwinResponse = await digitalTwinClient
  .GetDigitalTwinAsync<TemperatureControllerTwin>(digitalTwinId);

ThermostatTwin thermostat1 = getDigitalTwinResponse.Body.Thermostat1;

if (thermostat1 != null)
{
  // Thermostat1 is present in the TemperatureController twin. You can add/replace the component-level property "targetTemperature"
  double? currentComponentTargetTemperature = getDigitalTwinResponse.Body.Thermostat1.TargetTemperature;
  if (currentComponentTargetTemperature != null)
  {
      DateTimeOffset targetTemperatureDesiredLastUpdateTime = getDigitalTwinResponse.Body.Thermostat1.Metadata.TargetTemperature.LastUpdateTime;

      // The property path to be replaced should be prepended with a '/'
      updateOperation.AppendReplacePropertyOp("/thermostat1/targetTemperature", desiredTargetTemperature);
  }
  else
  {
      // The property path to be added should be prepended with a '/'
      updateOperation.AppendAddPropertyOp("/thermostat1/targetTemperature", desiredTargetTemperature);
  }
}
else
{
    // Thermostat1 is not present in the TemperatureController twin. Add the component.
    var componentProperty = new Dictionary<string, object> { { "targetTemperature", desiredTargetTemperature }, { "$metadata", new object() } };

    // The property path to be replaced should be prepended with a '/'
    updateOperation.AppendAddComponentOp("/thermostat1", componentProperty);
}

HttpOperationHeaderResponse<DigitalTwinUpdateHeaders> updateDigitalTwinResponse = await digitalTwinClient
    .UpdateDigitalTwinAsync(digitalTwinId, updateOperation.Serialize());

Console.WriteLine($"Update {digitalTwinId} digital twin response: {updateDigitalTwinResponse.Response.StatusCode}.");

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

DateTimeOffset since = DateTimeOffset.Now.Subtract(TimeSpan.FromMinutes(2));

try
{
  HttpOperationResponse<DigitalTwinCommandResponse, DigitalTwinInvokeCommandHeaders> invokeCommandResponse = await digitalTwinClient
    .InvokeCommandAsync(digitalTwinId, "getMaxMinReport", JsonConvert.SerializeObject(since));

  Console.WriteLine($"Command getMaxMinReport was invoked. \nDevice returned status: {invokeCommandResponse.Body.Status}." +
    $"\nReport: {invokeCommandResponse.Body.Payload}");
}
catch (HttpOperationException e)
{
  if (e.Response.StatusCode == HttpStatusCode.NotFound)
  {
    Console.WriteLine($"Unable to execute command getMaxMinReport on {digitalTwinId}.");
  }
}

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i Thermostat1-komponenten :

DateTimeOffset since = DateTimeOffset.Now.Subtract(TimeSpan.FromMinutes(2));

try
{
    HttpOperationResponse<DigitalTwinCommandResponse, DigitalTwinInvokeCommandHeaders> invokeCommandResponse = await digitalTwinClient
        .InvokeComponentCommandAsync(digitalTwinId, "thermostat1", "getMaxMinReport", JsonConvert.SerializeObject(since));

    Console.WriteLine("Command getMaxMinReport was invoked on component thermostat1." +
        $"\nDevice returned status: {invokeCommandResponse.Body.Status}. \nReport: {invokeCommandResponse.Body.Payload}");
}
catch (HttpOperationException e)
{
    if (e.Response.StatusCode == HttpStatusCode.NotFound)
    {
        Console.WriteLine("Unable to execute command getMaxMinReport on component thermostat1.");
    }
}

Läsa enhetstelemetri

IoT Plug and Play-enheter skickar telemetrin som definierats i DTDL-modellen till IoT Hub. Som standard dirigerar IoT Hub telemetrin till en Event Hubs-slutpunkt där du kan använda den. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till moln till olika slutpunkter.

Följande kodfragment visar hur du läser telemetrin från standardslutpunkten för Event Hubs. Koden i det här kodfragmentet hämtas från snabbstarten för IoT Hub Skicka telemetri från en enhet till en IoT-hubb och läs den med ett serverdelsprogram:

await using EventHubConsumerClient consumer = new EventHubConsumerClient(EventHubConsumerClient.DefaultConsumerGroupName, connectionString, EventHubName);

Console.WriteLine("Listening for messages on all partitions");

try
{
    await foreach (PartitionEvent partitionEvent in consumer.ReadEventsAsync(cancellationToken))
    {
        Console.WriteLine("Message received on partition {0}:", partitionEvent.Partition.PartitionId);

        string data = Encoding.UTF8.GetString(partitionEvent.Data.Body.ToArray());
        Console.WriteLine("\t{0}:", data);

        Console.WriteLine("Application properties (set by device):");
        foreach (var prop in partitionEvent.Data.Properties)
        {
            Console.WriteLine("\t{0}: {1}", prop.Key, prop.Value);
        }

        Console.WriteLine("System properties (set by IoT Hub):");
        foreach (var prop in partitionEvent.Data.SystemProperties)
        {
            Console.WriteLine("\t{0}: {1}", prop.Key, prop.Value);
        }
    }
}
catch (TaskCanceledException)
{
    // This is expected when the token is signaled; it should not be considered an
    // error in this scenario.
}

Följande utdata från föregående kod visar temperaturtelemetrin som skickas av termostat-IoT Plug and Play-enheten utan komponent som bara har standardkomponenten. Systemegenskapen dt-dataschema visar modell-ID:

Message received on partition 1:
        { "temperature": 25.5 }:
Application properties (set by device):
System properties (set by IoT Hub):
        iothub-connection-device-id: my-pnp-device
        iothub-connection-auth-method: {"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}
        iothub-connection-auth-generation-id: 637375045610235418
        iothub-enqueuedtime: 05/10/2020 14:30:58
        iothub-message-source: Telemetry
        dt-dataschema: dtmi:com:example:Thermostat;1
        content-type: application/json
        content-encoding: utf-8

Följande utdata från föregående kod visar den temperaturtelemetri som skickas av multikomponenten TemperatureController IoT Plug and Play-enheten. Systemegenskapen dt-subject visar namnet på komponenten som skickade telemetrin. I det här exemplet är thermostat1 de två komponenterna och thermostat2 enligt definitionen i DTDL-modellen. Systemegenskapen dt-dataschema visar modell-ID:

Message received on partition 1:
        {"temperature":11.1}:
Application properties (set by device):
System properties (set by IoT Hub):
        dt-subject: thermostat1
        iothub-connection-device-id: my-pnp-device
        iothub-connection-auth-method: {"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}
        iothub-connection-auth-generation-id: 637375045610235418
        iothub-enqueuedtime: 05/10/2020 14:23:36
        iothub-message-source: Telemetry
        dt-dataschema: dtmi:com:example:TemperatureController;1
        content-type: application/json
        content-encoding: utf-8
Message received on partition 1:
        {"temperature":41.2}:
Application properties (set by device):
System properties (set by IoT Hub):
        dt-subject: thermostat2
        iothub-connection-device-id: my-pnp-device
        iothub-connection-auth-method: {"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}
        iothub-connection-auth-generation-id: 637375045610235418
        iothub-enqueuedtime: 05/10/2020 14:23:36
        iothub-message-source: Telemetry
        dt-dataschema: dtmi:com:example:TemperatureController;1
        content-type: application/json
        content-encoding: utf-8

Läsa meddelanden om ändring av enhetstvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om enhetstvillingändringar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående C#-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om enhetstvillingändring för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Message received on partition 1:
        {"version":3,"properties":{"reported":{"maxTempSinceLastReboot":9.6,"$metadata":{"$lastUpdated":"2020-10-06T10:17:41.7408552Z","maxTempSinceLastReboot":{"$lastUpdated":"2020-10-06T10:17:41.7408552Z"}},"$version":2}}}:
Application properties (set by device):
        hubName: my-pnp-hub
        deviceId: my-pnp-device
        operationTimestamp: 2020-10-06T10:17:41.7408552+00:00
        iothub-message-schema: twinChangeNotification
        opType: updateTwin
System properties (set by IoT Hub):
        iothub-connection-device-id: my-pnp-device
        iothub-enqueuedtime: 06/10/2020 10:17:41
        iothub-message-source: twinChangeEvents
        user-id: System.ArraySegment`1[System.Byte]
        correlation-id: 61394e8ba7d
        content-type: application/json
        content-encoding: utf-8

Koden som visas i föregående C#-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om enhetstvillingändring för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Message received on partition 1:
        {"version":5,"properties":{"reported":{"thermostat1":{"__t":"c","maxTempSinceLastReboot":9.6},"$metadata":{"$lastUpdated":"2020-10-06T10:27:59.515972Z","thermostat1":{"$lastUpdated":"2020-10-06T10:27:59.515972Z","__t":{"$lastUpdated":"2020-10-06T10:27:59.515972Z"},"maxTempSinceLastReboot":{"$lastUpdated":"2020-10-06T10:27:59.515972Z"}}},"$version":4}}}:
Application properties (set by device):
        hubName: my-pnp-hub
        deviceId: my-pnp-device
        operationTimestamp: 2020-10-06T10:27:59.5159720+00:00
        iothub-message-schema: twinChangeNotification
        opType: updateTwin
System properties (set by IoT Hub):
        iothub-connection-device-id: my-pnp-device
        iothub-enqueuedtime: 06/10/2020 10:27:59
        iothub-message-source: twinChangeEvents
        user-id: System.ArraySegment`1[System.Byte]
        correlation-id: 615051f364e
        content-type: application/json
        content-encoding: utf-8

Läsa meddelanden om ändring av digitala tvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om ändring av digitala tvillingar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående C#-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om ändring av digitala tvillingar för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Message received on partition 1:
        [{"op":"add","path":"/$metadata/maxTempSinceLastReboot","value":{"lastUpdateTime":"2020-10-06T10:39:16.0209836Z"}},{"op":"add","path":"/maxTempSinceLastReboot","value":34.9}]:
Application properties (set by device):
        hubName: my-pnp-hub
        deviceId: my-pnp-device
        operationTimestamp: 2020-10-06T10:39:16.0209836+00:00
        iothub-message-schema: digitalTwinChangeNotification
        opType: updateTwin
System properties (set by IoT Hub):
        iothub-connection-device-id: my-pnp-device
        iothub-enqueuedtime: 06/10/2020 10:39:16
        iothub-message-source: digitalTwinChangeEvents
        user-id: System.ArraySegment`1[System.Byte]
        correlation-id: 6169857bf8c
        content-type: application/json-patch+json
        content-encoding: utf-8

Koden som visas i föregående C#-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om ändring av digitala tvillingar för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Message received on partition 1:
        [{"op":"add","path":"/thermostat1","value":{"$metadata":{"maxTempSinceLastReboot":{"lastUpdateTime":"2020-10-06T10:41:44.8312666Z"}},"maxTempSinceLastReboot":29.1}}]:
Application properties (set by device):
        hubName: my-pnp-hub
        deviceId: my-pnp-device
        operationTimestamp: 2020-10-06T10:41:44.8312666+00:00
        iothub-message-schema: digitalTwinChangeNotification
        opType: updateTwin
System properties (set by IoT Hub):
        iothub-connection-device-id: my-pnp-device
        iothub-enqueuedtime: 06/10/2020 10:41:44
        iothub-message-source: digitalTwinChangeEvents
        user-id: System.ArraySegment`1[System.Byte]
        correlation-id: 616f108f0e3
        content-type: application/json-patch+json
        content-encoding: utf-8

Följande resurser är också tillgängliga:

• Referensdokumentation för Java SDK
• Digital Twins-exempel

IoT Hub-tjänstklientexempel

Det här avsnittet visar Java-exempel med IoT Hub-tjänstklienten och deviceTwin - och DeviceMethod-klasserna från namnområdet com.microsoft.azure.sdk.iot.service.devicetwin . Du använder klassen DeviceTwin för att interagera med enhetstillståndet med hjälp av enhetstvillingar. Du kan också använda klassen DeviceTwin för att fråga efter enhetsregistreringar i din IoT Hub. Du använder klassen DeviceMethod för att anropa kommandon på enheten. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar. I kodfragmenten innehåller variabeln deviceId enhets-ID för IoT Plug and Play-enheten som är registrerad med din IoT-hubb.

Hämta enhetstvillingen och modell-ID:t

Så här hämtar du enhetstvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

DeviceTwin twinClient = DeviceTwin.createFromConnectionString(iotHubConnectionString);

// ...

DeviceTwinDevice twin = new DeviceTwinDevice(deviceId);
twinClient.getTwin(twin);
System.out.println("Model Id of this Twin is: " + twin.getModelId());

Uppdatera enhetstvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Du måste hämta tvillingen innan du uppdaterar den. Egenskapen definieras i enhetens standardkomponent:

DeviceTwin twinClient = DeviceTwin.createFromConnectionString(iotHubConnectionString);
DeviceTwinDevice twin = new DeviceTwinDevice(deviceId);
twinClient.getTwin(twin);

double propertyValue = 60.2;
twin.setDesiredProperties(Collections.singleton(new Pair("targetTemperature", propertyValue)));
twinClient.updateTwin(twin);

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Du måste hämta tvillingen innan du uppdaterar den. Egenskapen definieras i termostat1-komponenten :

public static Set<Pair> CreateComponentPropertyPatch(@NonNull String propertyName, @NonNull double propertyValue, @NonNull String componentName)
{
    JsonObject patchJson = new JsonObject();
    patchJson.addProperty("__t", "c");
    patchJson.addProperty(propertyName, propertyValue);
    return singleton(new Pair(componentName, patchJson));
}

// ...

DeviceTwin twinClient = DeviceTwin.createFromConnectionString(iotHubConnectionString);
DeviceTwinDevice twin = new DeviceTwinDevice(deviceId);
twinClient.getTwin(twin);

double propertyValue = 60.2;
twin.setDesiredProperties(CreateComponentPropertyPatch("targetTemperature", propertyValue, "thermostat1"));
twinClient.updateTwin(twin);

För en egenskap i en komponent ser egenskapskorrigeringen ut som följande exempel:

{
  "thermostat1":
  {
    "__t": "c",
    "targetTemperature": 60.2
  }
}

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

DeviceMethod methodClient = DeviceMethod.createFromConnectionString(iotHubConnectionString);

Long responseTimeout = TimeUnit.SECONDS.toSeconds(200);
Long connectTimeout = TimeUnit.SECONDS.toSeconds(5);

String commandInput = ZonedDateTime.now(ZoneOffset.UTC).minusMinutes(5).format(DateTimeFormatter.ISO_DATE_TIME);
MethodResult result = methodClient.invoke(deviceId, "getMaxMinReport", responseTimeout, connectTimeout, commandInput);

System.out.println("Method result status is: " + result.getStatus());

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i termostat1-komponenten :

DeviceMethod methodClient = DeviceMethod.createFromConnectionString(iotHubConnectionString);

Long responseTimeout = TimeUnit.SECONDS.toSeconds(200);
Long connectTimeout = TimeUnit.SECONDS.toSeconds(5);

String commandInput = ZonedDateTime.now(ZoneOffset.UTC).minusMinutes(5).format(DateTimeFormatter.ISO_DATE_TIME);
MethodResult result = methodClient.invoke(deviceId, "thermostat1*getMaxMinReport", responseTimeout, connectTimeout, commandInput);

System.out.println("Method result status is: " + result.getStatus());

Exempel på digitala IoT Hub-tvillingar

Du använder klassen DigitalTwinAsyncClient i namnområdet com.microsoft.azure.sdk.iot.service.digitaltwin för att interagera med enhetstillståndet med hjälp av digitala tvillingar. I följande exempel används även klasserna UpdateOperationUtility och BasicDigitalTwin från samma namnområde. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar.

Variabeln digitalTwinid innehåller enhets-ID för IoT Plug and Play-enheten som registrerats med din IoT-hubb.

Hämta den digitala tvillingen och modell-ID:t

Så här hämtar du den digitala tvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

DigitalTwinAsyncClient asyncClient = DigitalTwinAsyncClient.createFromConnectionString(iotHubConnectionString);

CountDownLatch latch = new CountDownLatch(1);
asyncClient.getDigitalTwin(digitalTwinid, BasicDigitalTwin.class)
    .subscribe(
        getResponse ->
        {
            System.out.println("Digital Twin Model Id: " + getResponse.getMetadata().getModelId());
            System.out.println("Digital Twin: " + prettyBasicDigitalTwin(getResponse));
            latch.countDown();
        },
        error ->
        {
            System.out.println("Get Digital Twin failed: " + error);
            latch.countDown();
        });

latch.await(10, TimeUnit.SECONDS);

// ...

private static String prettyBasicDigitalTwin(BasicDigitalTwin basicDigitalTwin)
{
    Gson gson = new GsonBuilder().setPrettyPrinting().create();
    return gson.toJson(basicDigitalTwin);
}

Uppdatera digital tvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Egenskapen definieras i enhetens standardkomponent:

DigitalTwinAsyncClient asyncClient = DigitalTwinAsyncClient.createFromConnectionString(iotHubConnectionString);

CountDownLatch latch1 = new CountDownLatch(1);

UpdateOperationUtility updateOperationUtility = new UpdateOperationUtility();

// Add a new property.
updateOperationUtility.appendAddPropertyOperation("/" + "targetTemperature", 35);
asyncClient.updateDigitalTwin(digitalTwinid, updateOperationUtility.getUpdateOperations())
    .subscribe(
        getResponse ->
        {
            System.out.println("Updated Digital Twin");
            latch1.countDown();
        },
        error ->
        {
            System.out.println("Update Digital Twin failed: " + error);
            latch1.countDown();
        });
latch1.await(10, TimeUnit.SECONDS);
GetDigitalTwin();

// Replace an existing property.
CountDownLatch latch2 = new CountDownLatch(1);
updateOperationUtility.appendReplacePropertyOperation("/targetTemperature", 50);
asyncClient.updateDigitalTwin(digitalTwinid, updateOperationUtility.getUpdateOperations())
    .subscribe(
        getResponse ->
        {
            System.out.println("Updated Digital Twin");
            latch2.countDown();
        },
        error ->
        {
            System.out.println("Update Digital Twin failed: " + error);
            latch2.countDown();
        });

latch2.await(10, TimeUnit.SECONDS);
GetDigitalTwin();

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Egenskapen definieras i termostat1-komponenten :

DigitalTwinClient client = DigitalTwinClient.createFromConnectionString(iotHubConnectionString);

// Get digital twin.
ServiceResponseWithHeaders<String, DigitalTwinGetHeaders> getResponse = client.getDigitalTwinWithResponse(digitalTwinid, String.class);

// Construct the options for conditional update.
DigitalTwinUpdateRequestOptions options = new DigitalTwinUpdateRequestOptions();
options.setIfMatch(getResponse.headers().eTag());

UpdateOperationUtility updateOperationUtility = new UpdateOperationUtility();

Map<String, Object> t1properties = new HashMap<>();
t1properties.put("targetTemperature", 50);
updateOperationUtility.appendReplaceComponentOperation("/thermostat1", t1properties);

digitalTwinUpdateOperations = updateOperationUtility.getUpdateOperations();
updateResponse = client.updateDigitalTwinWithResponse(digitalTwinid, digitalTwinUpdateOperations, options);
System.out.println("Update Digital Twin response status: " + updateResponse.response().message());

getResponse = client.getDigitalTwinWithResponse(digitalTwinid, String.class);

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

CountDownLatch latch = new CountDownLatch(1);

String commandInput = ZonedDateTime.now(ZoneOffset.UTC).minusMinutes(5).format(DateTimeFormatter.ISO_DATE_TIME);

// Invoke a method on root level.
asyncClient.invokeCommand(digitalTwinid, "getMaxMinReport", commandInput)
    .subscribe(
        response ->
        {
            System.out.println("Invoked Command getMaxMinReport response: " + prettyString(response.getPayload()));
            latch.countDown();
        },
        error ->
        {
            RestException ex = (RestException)error;
            if(ex.response().code() == 404) {
                System.out.println("Invoked Command getMaxMinReport failed: " + error);
            }
            else {
                System.out.println("Ensure the device sample is running for this sample to succeed");
            }
            latch.countDown();
        });

latch.await(10, TimeUnit.SECONDS);

// ...

private static String prettyString(String str)
{
    Gson gson = new Gson();
    Gson gsonBuilder = new GsonBuilder().setPrettyPrinting().create();
    return gsonBuilder.toJson(gson.fromJson(str, Object.class));
}

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i termostat1-komponenten :

DigitalTwinClient client = DigitalTwinClient.createFromConnectionString(iotHubConnectionString);

String commandInput = ZonedDateTime.now(ZoneOffset.UTC).minusMinutes(5).format(DateTimeFormatter.ISO_DATE_TIME);

DigitalTwinInvokeCommandRequestOptions options = new DigitalTwinInvokeCommandRequestOptions();
try {
    ServiceResponseWithHeaders<DigitalTwinCommandResponse, DigitalTwinInvokeCommandHeaders> commandResponse = client.invokeComponentCommandWithResponse(digitalTwinid, "thermostat1", "getMaxMinReport", commandInput, options);
    System.out.println("Command getMaxMinReport, payload: " + prettyString(commandResponse.body().getPayload()));
    System.out.println("Command getMaxMinReport, status: " + commandResponse.body().getStatus());
} catch (RestException ex)
{
    if(ex.response().code() == 404)
    {
        System.out.println("Ensure the device sample is running for this sample to succeed.");
    }
    else
    {
        throw ex;
    }
}

// ...

private static String prettyString(String str)
{
    Gson gson = new Gson();
    Gson gsonBuilder = new GsonBuilder().setPrettyPrinting().create();
    return gsonBuilder.toJson(gson.fromJson(str, Object.class));
}

Läsa enhetstelemetri

IoT Plug and Play-enheter skickar telemetrin som definierats i DTDL-modellen till IoT Hub. Som standard dirigerar IoT Hub telemetrin till en Event Hubs-slutpunkt där du kan använda den. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till moln till olika slutpunkter.

Följande kodfragment visar hur du läser telemetrin från standardslutpunkten för Event Hubs. Koden i det här kodfragmentet hämtas från snabbstarten för IoT Hub Skicka telemetri från en enhet till en IoT-hubb och läs den med ett serverdelsprogram:

import com.azure.messaging.eventhubs.EventHubClientBuilder;
import com.azure.messaging.eventhubs.EventHubConsumerAsyncClient;

// ...

EventHubClientBuilder eventHubClientBuilder = new EventHubClientBuilder()
    .consumerGroup(EventHubClientBuilder.DEFAULT_CONSUMER_GROUP_NAME)
    .connectionString(eventHubCompatibleConnectionString);

try (EventHubConsumerAsyncClient eventHubConsumerAsyncClient = eventHubClientBuilder.buildAsyncConsumerClient()) {

    receiveFromAllPartitions(eventHubConsumerAsyncClient);

}

// ...

private static void receiveFromAllPartitions(EventHubConsumerAsyncClient eventHubConsumerAsyncClient) {

eventHubConsumerAsyncClient
    .receive(false) // set this to false to read only the newly available events
    .subscribe(partitionEvent -> {
        System.out.println();
        System.out.printf("%nTelemetry received from partition %s:%n%s",
            partitionEvent.getPartitionContext().getPartitionId(), partitionEvent.getData().getBodyAsString());
        System.out.printf("%nApplication properties (set by device):%n%s", partitionEvent.getData().getProperties());
        System.out.printf("%nSystem properties (set by IoT Hub):%n%s",
            partitionEvent.getData().getSystemProperties());
    }, ex -> {
        System.out.println("Error receiving events " + ex);
    }, () -> {
        System.out.println("Completed receiving events");
    });
}

Följande utdata från föregående kod visar temperaturtelemetrin som skickas av termostat-IoT Plug and Play-enheten utan komponent som bara har standardkomponenten. Systemegenskapen dt-dataschema visar modell-ID:

Telemetry received from partition 1:
{"temperature": 10.700000}
Application properties (set by device):
{$.cdid=my-pnp-device}
System properties (set by IoT Hub):
{correlation-id=aaaa0000-bb11-2222-33cc-444444dddddd, content-encoding=UTF-8, iothub-connection-auth-method={"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}, iothub-enqueuedtime=Tue Oct 20 12:28:10 BST 2020, dt-dataschema=dtmi:com:example:Thermostat;1, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, iothub-connection-auth-generation-id=637375776990653481, group-sequence=0, iothub-message-source=Telemetry, creation-time=0, message-id=aaaabbbb-0000-cccc-1111-dddd2222eeee, content-type=application/json}

Telemetry received from partition 1:
{"temperature": 10.700000}
Application properties (set by device):
{$.cdid=my-pnp-device}
System properties (set by IoT Hub):
{correlation-id=bbbb1111-cc22-3333-44dd-555555eeeeee, content-encoding=UTF-8, iothub-connection-auth-method={"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}, iothub-enqueuedtime=Tue Oct 20 12:28:15 BST 2020, dt-dataschema=dtmi:com:example:Thermostat;1, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, iothub-connection-auth-generation-id=637375776990653481, group-sequence=0, iothub-message-source=Telemetry, creation-time=0, message-id=bbbbcccc-1111-dddd-2222-eeee3333ffff, content-type=application/json}

Följande utdata från föregående kod visar den temperaturtelemetri som skickas av multikomponenten TemperatureController IoT Plug and Play-enheten. Systemegenskapen dt-subject visar namnet på komponenten som skickade telemetrin. I det här exemplet är thermostat1 de två komponenterna och thermostat2 enligt definitionen i DTDL-modellen. Systemegenskapen dt-dataschema visar modell-ID:

Telemetry received from partition 1:
null
Application properties (set by device):
{$.cdid=my-pnp-device}
System properties (set by IoT Hub):
{correlation-id=cccc2222-dd33-4444-55ee-666666ffffff, content-encoding=UTF-8, iothub-connection-auth-method={"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}, iothub-enqueuedtime=Tue Oct 20 12:31:14 BST 2020, dt-dataschema=dtmi:com:example:TemperatureController;1, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, iothub-connection-auth-generation-id=637387902591517456, group-sequence=0, iothub-message-source=Telemetry, creation-time=0, message-id=ccccdddd-2222-eeee-3333-ffff4444aaaa, content-type=application/json, dt-subject=thermostat1}

Telemetry received from partition 1:
null
Application properties (set by device):
{$.cdid=my-pnp-device}
System properties (set by IoT Hub):
{correlation-id=dddd3333-ee44-5555-66ff-777777aaaaaa, content-encoding=UTF-8, iothub-connection-auth-method={"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}, iothub-enqueuedtime=Tue Oct 20 12:31:14 BST 2020, dt-dataschema=dtmi:com:example:TemperatureController;1, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, iothub-connection-auth-generation-id=637387902591517456, group-sequence=0, iothub-message-source=Telemetry, creation-time=0, message-id=ddddeeee-3333-ffff-4444-aaaa5555bbbb, content-type=application/json, dt-subject=thermostat2}

Läsa meddelanden om ändring av enhetstvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om enhetstvillingändringar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående Java-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om enhetstvillingändring för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received from partition 1:
{"version":11,"properties":{"reported":{"maxTempSinceLastReboot":43.4,"$metadata":{"$lastUpdated":"2020-10-20T11:50:41.123127Z","maxTempSinceLastReboot":{"$lastUpdated":"2020-10-20T11:50:41.123127Z"}},"$version":10}}}
Application properties (set by device):
{operationTimestamp=2020-10-20T11:50:41.1231270+00:00, opType=updateTwin, hubName=my-pnp-hub, deviceId=my-pnp-device, iothub-message-schema=twinChangeNotification}
System properties (set by IoT Hub):
{user-id=[B@12fd5bb4, correlation-id=11339418426a, content-encoding=utf-8, iothub-enqueuedtime=Tue Oct 20 12:50:41 BST 2020, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, group-sequence=0, iothub-message-source=twinChangeEvents, creation-time=0, content-type=application/json}

Koden som visas i föregående Java-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om enhetstvillingändring för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received from partition 1:
{"version":9,"properties":{"reported":{"thermostat1":{"__t":"c","maxTempSinceLastReboot":32.5},"$metadata":{"$lastUpdated":"2020-10-20T11:48:01.2960851Z","thermostat1":{"$lastUpdated":"2020-10-20T11:48:01.2960851Z","__t":{"$lastUpdated":"2020-10-20T11:48:01.2960851Z"},"maxTempSinceLastReboot":{"$lastUpdated":"2020-10-20T11:48:01.2960851Z"}}},"$version":8}}}
Application properties (set by device):
{operationTimestamp=2020-10-20T11:48:01.2960851+00:00, opType=updateTwin, hubName=my-pnp-hub, deviceId=my-pnp-device, iothub-message-schema=twinChangeNotification}
System properties (set by IoT Hub):
{user-id=[B@23949bae, correlation-id=113334d542e1, content-encoding=utf-8, iothub-enqueuedtime=Tue Oct 20 12:48:01 BST 2020, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, group-sequence=0, iothub-message-source=twinChangeEvents, creation-time=0, content-type=application/json}

Läsa meddelanden om ändring av digitala tvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om ändring av digitala tvillingar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående Java-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om ändring av digitala tvillingar för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received from partition 1:
[{"op":"replace","path":"/$metadata/maxTempSinceLastReboot/lastUpdateTime","value":"2020-10-20T11:52:40.627628Z"},{"op":"replace","path":"/maxTempSinceLastReboot","value":16.9}]
Application properties (set by device):
{operationTimestamp=2020-10-20T11:52:40.6276280+00:00, opType=updateTwin, hubName=my-pnp-hub, deviceId=my-pnp-device, iothub-message-schema=digitalTwinChangeNotification}
System properties (set by IoT Hub):
{user-id=[B@4475ce2a, correlation-id=1133db52c0e0, content-encoding=utf-8, iothub-enqueuedtime=Tue Oct 20 12:52:40 BST 2020, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, group-sequence=0, iothub-message-source=digitalTwinChangeEvents, creation-time=0, content-type=application/json-patch+json}

Koden som visas i föregående Java-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om ändring av digitala tvillingar för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received from partition 1:
[{"op":"add","path":"/thermostat1","value":{"$metadata":{"maxTempSinceLastReboot":{"lastUpdateTime":"2020-10-20T11:31:04.7811405Z"}},"maxTempSinceLastReboot":27.2}}]
Application properties (set by device):
{operationTimestamp=2020-10-20T11:31:04.7811405+00:00, opType=updateTwin, hubName=my-pnp-hub, deviceId=my-pnp-device, iothub-message-schema=digitalTwinChangeNotification}
System properties (set by IoT Hub):
{user-id=[B@75981aa, correlation-id=1130d6f4d212, content-encoding=utf-8, iothub-enqueuedtime=Tue Oct 20 12:31:04 BST 2020, absolute-expiry-time=0, iothub-connection-device-id=my-pnp-device, group-sequence=0, iothub-message-source=digitalTwinChangeEvents, creation-time=0, content-type=application/json-patch+json}

Följande resurser är också tillgängliga:

• referensdokumentation för Node.js SDK
• Tjänstklientexempel
• Digital Twins-exempel

IoT Hub-tjänstklientexempel

Det här avsnittet visar JavaScript-exempel med IoT Hub-tjänstklienten och klasserna Register och Klient . Du använder klassen Registry för att interagera med enhetstillståndet med hjälp av enhetstvillingar. Du kan också använda klassen Registry för att köra frågor mot enhetsregistreringar i din IoT Hub. Du använder klassen Klient för att anropa kommandon på enheten. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar. I kodfragmenten innehåller variabeln deviceId enhets-ID för IoT Plug and Play-enheten som är registrerad med din IoT-hubb.

Hämta enhetstvillingen och modell-ID:t

Så här hämtar du enhetstvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

var Registry = require('azure-iothub').Registry;

// ...

var registry = Registry.fromConnectionString(connectionString);
registry.getTwin(deviceId, function(err, twin) {
  if (err) {
    console.error(err.message);
  } else {
    console.log('Model Id: ' + twin.modelId);
    console.log(JSON.stringify(twin, null, 2));
  }
}

Uppdatera enhetstvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Exemplet visar hur du behöver hämta tvillingen innan du uppdaterar den. Egenskapen definieras i enhetens standardkomponent:

var Registry = require('azure-iothub').Registry;
var registry = Registry.fromConnectionString(connectionString);

registry.getTwin(deviceId, function(err, twin) {
  if (err) {
    console.error(err.message);
  } else {
    var twinPatch = {
      properties: {
        desired: {
          targetTemperature: 42
        }
      }
    };
    twin.update(twinPatch, function(err, twin) {
      if (err) {
        console.error(err.message);
      } else {
        console.log(JSON.stringify(twin, null, 2));
      }
    }
  }
}

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Exemplet visar hur du behöver hämta tvillingen innan du uppdaterar den. Egenskapen definieras i termostat1-komponenten :

var Registry = require('azure-iothub').Registry;
var registry = Registry.fromConnectionString(connectionString);

registry.getTwin(deviceId, function(err, twin) {
  if (err) {
    console.error(err.message);
  } else {
    var twinPatch = {
      properties: {
        desired: {
          thermostat1:
          {
            __t: "c",
            targetTemperature: 45
          }
        }
      }
    };
    twin.update(twinPatch, function(err, twin) {
      if (err) {
        console.error(err.message);
      } else {
        console.log(JSON.stringify(twin, null, 2));
      }
    }
  }
}

För en egenskap i en komponent ser egenskapskorrigeringen ut som följande exempel:

{
  "thermostat1":
  {
    "__t": "c",
    "targetTemperature": 20
  }
}

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

var Client = require('azure-iothub').Client;

// ...

var client = Client.fromConnectionString(connectionString);

var methodParams = {
  methodName: "getMaxMinReport",
  payload: new Date().getMinutes -2,
  responseTimeoutInSeconds: 15
};

client.invokeDeviceMethod(deviceId, methodParams, function (err, result) {
  if (err) {
    console.error('Failed to invoke method \'' + methodParams.methodName + '\': ' + err.message);
  } else {
    console.log(methodParams.methodName + ' on ' + deviceId + ':');
    console.log(JSON.stringify(result, null, 2));
  }
});

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i termostat1-komponenten :

var Client = require('azure-iothub').Client;

// ...

var client = Client.fromConnectionString(connectionString);

var methodParams = {
  methodName: "thermostat1*getMaxMinReport",
  payload: new Date().getMinutes -2,
  responseTimeoutInSeconds: 15
};

client.invokeDeviceMethod(deviceId, methodParams, function (err, result) {
  if (err) {
    console.error('Failed to invoke method \'' + methodParams.methodName + '\': ' + err.message);
  } else {
    console.log(methodParams.methodName + ' on ' + deviceId + ':');
    console.log(JSON.stringify(result, null, 2));
  }
});

Exempel på digitala IoT Hub-tvillingar

Du använder klassen DigitalTwinClient för att interagera med enhetstillståndet med hjälp av digitala tvillingar. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar.

Det här avsnittet visar JavaScript-exempel med hjälp av Digital Twins-API:et.

Variabeln digitalTwinId innehåller enhets-ID för IoT Plug and Play-enheten som registrerats med din IoT-hubb.

Hämta den digitala tvillingen och modell-ID:t

Så här hämtar du den digitala tvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

const IoTHubTokenCredentials = require('azure-iothub').IoTHubTokenCredentials;
const DigitalTwinClient = require('azure-iothub').DigitalTwinClient;
const { inspect } = require('util');

// ...

const credentials = new IoTHubTokenCredentials(connectionString);
const digitalTwinClient = new DigitalTwinClient(credentials);

const digitalTwin = await digitalTwinClient.getDigitalTwin(digitalTwinId);

console.log(inspect(digitalTwin));
console.log('Model Id: ' + inspect(digitalTwin.$metadata.$model));

Uppdatera digital tvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Egenskapen definieras i enhetens standardkomponent:

const IoTHubTokenCredentials = require('azure-iothub').IoTHubTokenCredentials;
const DigitalTwinClient = require('azure-iothub').DigitalTwinClient;

// ...

const credentials = new IoTHubTokenCredentials(connString);
const digitalTwinClient = new DigitalTwinClient(credentials);

const patch = [{
  op: 'add',
  path: '/targetTemperature',
  value: 42
}];
await digitalTwinClient.updateDigitalTwin(digitalTwinId, patch);

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Egenskapen definieras i termostat1-komponenten :

const IoTHubTokenCredentials = require('azure-iothub').IoTHubTokenCredentials;
const DigitalTwinClient = require('azure-iothub').DigitalTwinClient;

// ...

const credentials = new IoTHubTokenCredentials(connString);
const digitalTwinClient = new DigitalTwinClient(credentials);

const patch = [{
  op: 'add',
  path: '/thermostat1/targetTemperature',
  value: 42
}];
await digitalTwinClient.updateDigitalTwin(digitalTwinId, patch);

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

const IoTHubTokenCredentials = require('azure-iothub').IoTHubTokenCredentials;
const DigitalTwinClient = require('azure-iothub').DigitalTwinClient;
const { inspect } = require('util');

// ...

const commandPayload = new Date().getMinutes -2;

const credentials = new IoTHubTokenCredentials(connectionString);
const digitalTwinClient = new DigitalTwinClient(credentials);

const options = {
  connectTimeoutInSeconds: 30,
  responseTimeoutInSeconds: 40
};
const commandResponse = await digitalTwinClient.invokeCommand(digitalTwinId, "getMaxMinReport", commandPayload, options);

console.log(inspect(commandResponse));

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i termostat1-komponenten :

const IoTHubTokenCredentials = require('azure-iothub').IoTHubTokenCredentials;
const DigitalTwinClient = require('azure-iothub').DigitalTwinClient;
const { inspect } = require('util');

// ...

const commandPayload = new Date().getMinutes -2;

const credentials = new IoTHubTokenCredentials(connectionString);
const digitalTwinClient = new DigitalTwinClient(credentials);

const options = {
  connectTimeoutInSeconds: 30,
  responseTimeoutInSeconds: 40
};
const commandResponse = await digitalTwinClient.invokeComponentCommand(digitalTwinId, "thermostat1", "getMaxMinReport", commandPayload, options);

console.log(inspect(commandResponse));

Läsa enhetstelemetri

IoT Plug and Play-enheter skickar telemetrin som definierats i DTDL-modellen till IoT Hub. Som standard dirigerar IoT Hub telemetrin till en Event Hubs-slutpunkt där du kan använda den. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till moln till olika slutpunkter.

Följande kodfragment visar hur du läser telemetrin från standardslutpunkten för Event Hubs. Koden i det här kodfragmentet hämtas från snabbstarten för IoT Hub Skicka telemetri från en enhet till en IoT-hubb och läs den med ett serverdelsprogram:

const { EventHubConsumerClient } = require("@azure/event-hubs");

var printError = function (err) {
  console.log(err.message);
};

var printMessages = function (messages) {
  for (const message of messages) {
    console.log("Telemetry received: ");
    console.log(JSON.stringify(message.body));
    console.log("Properties (set by device): ");
    console.log(JSON.stringify(message.properties));
    console.log("System properties (set by IoT Hub): ");
    console.log(JSON.stringify(message.systemProperties));
    console.log("");
  }
};

// ...

const clientOptions = {};

const consumerClient = new EventHubConsumerClient("$Default", connectionString, clientOptions);

consumerClient.subscribe({
  processEvents: printMessages,
  processError: printError,
});

Följande utdata från föregående kod visar den temperaturtelemetri som skickas av multikomponenten TemperatureController IoT Plug and Play-enheten. Systemegenskapen dt-subject visar namnet på komponenten som skickade telemetrin. I det här exemplet är thermostat1 de två komponenterna och thermostat2 enligt definitionen i DTDL-modellen. Systemegenskapen dt-dataschema visar modell-ID:

Telemetry received:
{"temperature":68.77370855171125}
Properties (set by device):
undefined
System properties (set by IoT Hub):
{"iothub-connection-device-id":"my-pnp-device","iothub-connection-auth-method":"{\"scope\":\"device\",\"type\":\"sas\",\"issuer\":\"iothub\",\"acceptingIpFilterRule\":null}","iothub-connection-auth-generation-id":"637388034455888246","iothub-enqueuedtime":1603206669320,"iothub-message-source":"Telemetry","dt-subject":"thermostat1","dt-dataschema":"dtmi:com:example:TemperatureController;1","contentType":"application/json","contentEncoding":"utf-8"}

Telemetry received:
{"temperature":30.833394506549226}
Properties (set by device):
undefined
System properties (set by IoT Hub):
{"iothub-connection-device-id":"my-pnp-device","iothub-connection-auth-method":"{\"scope\":\"device\",\"type\":\"sas\",\"issuer\":\"iothub\",\"acceptingIpFilterRule\":null}","iothub-connection-auth-generation-id":"637388034455888246","iothub-enqueuedtime":1603206665835,"iothub-message-source":"Telemetry","dt-subject":"thermostat2","dt-dataschema":"dtmi:com:example:TemperatureController;1","contentType":"application/json","contentEncoding":"utf-8"}

Läsa meddelanden om ändring av enhetstvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om enhetstvillingändringar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående JavaScript-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om enhetstvillingändring för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received:
{"version":4,"properties":{"reported":{"maxTempSinceLastReboot":42.1415152639582,"$metadata":{"$lastUpdated":"2020-10-21T10:01:40.1281138Z","maxTempSinceLastReboot":{"$lastUpdated":"2020-10-21T10:01:40.1281138Z"}},"$version":3}}}
Properties (set by device):
{"hubName":"my-pnp-hub","deviceId":"my-pnp-device","operationTimestamp":"2020-10-21T10:01:40.1281138+00:00","iothub-message-schema":"twinChangeNotification","opType":"updateTwin"}
System properties (set by IoT Hub):
{"iothub-connection-device-id":"my-pnp-device","iothub-enqueuedtime":1603274500282,"iothub-message-source":"twinChangeEvents","userId":{"type":"Buffer","data":[109,121,45,112,110,112,45,104,117,98]},"correlationId":"11ed82d13f50","contentType":"application/json","contentEncoding":"utf-8"}

Koden som visas i föregående JavaScript-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om enhetstvillingändring för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received:
{"version":4,"properties":{"reported":{"thermostat1":{"maxTempSinceLastReboot":3.5592971602417913,"__t":"c"},"$metadata":{"$lastUpdated":"2020-10-21T10:07:51.8284866Z","thermostat1":{"$lastUpdated":"2020-10-21T10:07:51.8284866Z","maxTempSinceLastReboot":{"$lastUpdated":"2020-10-21T10:07:51.8284866Z"},"__t":{"$lastUpdated":"2020-10-21T10:07:51.8284866Z"}}},"$version":3}}}
Properties (set by device):
{"hubName":"my-pnp-hub","deviceId":"my-pnp-device","operationTimestamp":"2020-10-21T10:07:51.8284866+00:00","iothub-message-schema":"twinChangeNotification","opType":"updateTwin"}
System properties (set by IoT Hub):
{"iothub-connection-device-id":"my-pnp-device","iothub-enqueuedtime":1603274871951,"iothub-message-source":"twinChangeEvents","userId":{"type":"Buffer","data":[109,121,45,112,110,112,45,104,117,98]},"correlationId":"11ee605b195f","contentType":"application/json","contentEncoding":"utf-8"}

Läsa meddelanden om ändring av digitala tvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om ändring av digitala tvillingar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående JavaScript-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om ändring av digitala tvillingar för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received:
[{"op":"add","path":"/$metadata/maxTempSinceLastReboot","value":{"lastUpdateTime":"2020-10-21T10:01:40.1281138Z"}},{"op":"add","path":"/maxTempSinceLastReboot","value":42.1415152639582}]
Properties (set by device):
{"hubName":"my-pnp-hub","deviceId":"my-pnp-device","operationTimestamp":"2020-10-21T10:01:40.1281138+00:00","iothub-message-schema":"digitalTwinChangeNotification","opType":"updateTwin"}
System properties (set by IoT Hub):
{"iothub-connection-device-id":"my-pnp-device","iothub-enqueuedtime":1603274500282,"iothub-message-source":"digitalTwinChangeEvents","userId":{"type":"Buffer","data":[109,121,45,112,110,112,45,104,117,98]},"correlationId":"11ed82d13f50","contentType":"application/json-patch+json","contentEncoding":"utf-8"}

Koden som visas i föregående JavaScript-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om digital tvillingändring för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Telemetry received:
[{"op":"add","path":"/thermostat1","value":{"$metadata":{"maxTempSinceLastReboot":{"lastUpdateTime":"2020-10-21T10:07:51.8284866Z"}},"maxTempSinceLastReboot":3.5592971602417913}}]
Properties (set by device):
{"hubName":"my-pnp-hub","deviceId":"my-pnp-device","operationTimestamp":"2020-10-21T10:07:51.8284866+00:00","iothub-message-schema":"digitalTwinChangeNotification","opType":"updateTwin"}
System properties (set by IoT Hub):
{"iothub-connection-device-id":"my-pnp-device","iothub-enqueuedtime":1603274871951,"iothub-message-source":"digitalTwinChangeEvents","userId":{"type":"Buffer","data":[109,121,45,112,110,112,45,104,117,98]},"correlationId":"11ee605b195f","contentType":"application/json-patch+json","contentEncoding":"utf-8"}

Följande resurser är också tillgängliga:

• Referensdokumentation för Python SDK
• Tjänstklientexempel
• Digital Twins-exempel

IoT Hub-tjänstklientexempel

Det här avsnittet visar Python-exempel med IoT Hub-tjänstklienten och klasserna IoTHubRegistryManager och CloudToDeviceMethod . Du använder klassen IoTHubRegistryManager för att interagera med enhetstillståndet med hjälp av enhetstvillingar. Du kan också använda klassen IoTHubRegistryManager för att köra frågor mot enhetsregistreringar i din IoT Hub. Du använder klassen CloudToDeviceMethod för att anropa kommandon på enheten. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar. I kodfragmenten innehåller variabeln device_id enhets-ID för IoT Plug and Play-enheten som är registrerad med din IoT-hubb.

Hämta enhetstvillingen och modell-ID:t

Så här hämtar du enhetstvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

from azure.iot.hub import IoTHubRegistryManager
from azure.iot.hub.models import Twin, TwinProperties

iothub_registry_manager = IoTHubRegistryManager(iothub_connection_str)

# ...

twin = iothub_registry_manager.get_twin(device_id)
print("The device twin is: ")
print("")
print(twin)
print("")

additional_props = twin.additional_properties
if "modelId" in additional_props:
    print("The Model ID for this device is:")
    print(additional_props["modelId"])
    print("")

Uppdatera enhetstvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Exemplet visar hur du behöver hämta tvillingens etag innan du uppdaterar den. Egenskapen definieras i enhetens standardkomponent:

iothub_registry_manager = IoTHubRegistryManager(iothub_connection_str)

twin = iothub_registry_manager.get_twin(device_id)

twin_patch = Twin()

twin_patch.properties = TwinProperties(
    desired={"targetTemperature": 42}
)
updated_twin = iothub_registry_manager.update_twin(device_id, twin_patch, twin.etag)

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Exemplet visar hur du behöver hämta tvillingens ETag innan du uppdaterar den. Egenskapen definieras i termostat1-komponenten :

iothub_registry_manager = IoTHubRegistryManager(iothub_connection_str)

twin = iothub_registry_manager.get_twin(device_id)

twin_patch = Twin()

twin_patch.properties = TwinProperties(
    desired={ "thermostat1": {
        "__t": "c",
        "targetTemperature": 42}
    }
)
updated_twin = iothub_registry_manager.update_twin(device_id, twin_patch, twin.etag)

För en egenskap i en komponent ser egenskapskorrigeringen ut som följande exempel:

{
"thermostat1":
  {
    "__t": "c",
    "targetTemperature": 20
  }
}

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

from azure.iot.hub import IoTHubRegistryManager
from azure.iot.hub.models import CloudToDeviceMethod

# ...

iothub_registry_manager = IoTHubRegistryManager(iothub_connection_str)

method_payload = datetime.datetime.now() - datetime.timedelta(minutes=2)
device_method = CloudToDeviceMethod(method_name="getMaxMinReport", payload=method_payload)
result = iothub_registry_manager.invoke_device_method(device_id, device_method)
print(result.payload)

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i termostat1-komponenten :

from azure.iot.hub import IoTHubRegistryManager
from azure.iot.hub.models import CloudToDeviceMethod

# ...

iothub_registry_manager = IoTHubRegistryManager(iothub_connection_str)

method_payload = datetime.datetime.now() - datetime.timedelta(minutes=2)
device_method = CloudToDeviceMethod(method_name="thermostat1*getMaxMinReport", payload=method_payload)
result = iothub_registry_manager.invoke_device_method(device_id, device_method)
print(result.payload)

Exempel på digitala IoT Hub-tvillingar

Du använder klassen DigitalTwinClient för att interagera med enhetstillståndet med hjälp av digitala tvillingar. DTDL-modellen för enheten definierar de egenskaper och kommandon som enheten implementerar.

Variabeln device_id innehåller enhets-ID för IoT Plug and Play-enheten som registrerats med din IoT-hubb.

Hämta den digitala tvillingen och modell-ID:t

Så här hämtar du den digitala tvillingen och modell-ID:t för IoT Plug and Play-enheten som är ansluten till din IoT-hubb:

from azure.iot.hub import DigitalTwinClient

digital_twin_client = DigitalTwinClient(iothub_connection_str)

digital_twin = digital_twin_client.get_digital_twin(device_id)
if digital_twin:
    print(digital_twin)
    print("Model Id: " + digital_twin["$metadata"]["$model"])
else:
    print("No digital_twin found")

Uppdatera digital tvilling

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen på en enhet. Egenskapen definieras i enhetens standardkomponent:

from azure.iot.hub import DigitalTwinClient

digital_twin_client = DigitalTwinClient(iothub_connection_str)

patch = [{"op": "add", "path": "/targetTemperature", "value": 42}]
digital_twin_client.update_digital_twin(device_id, patch)

Följande kodfragment visar hur du targetTemperature uppdaterar egenskapen för en komponent. Egenskapen definieras i termostat1-komponenten :

from azure.iot.hub import DigitalTwinClient

digital_twin_client = DigitalTwinClient(iothub_connection_str)

patch = [{"op": "add", "path": "/targetTemperature", "value": 42}]
digital_twin_client.update_digital_twin(device_id, patch)

Samtalskommando

Följande kodfragment visar hur du anropar getMaxMinReport kommandot som definierats i en standardkomponent:

from azure.iot.hub import DigitalTwinClient

payload = datetime.datetime.now() - datetime.timedelta(minutes=2)

connect_timeout_in_seconds = 3
response_timeout_in_seconds = 7


digital_twin_client = DigitalTwinClient(iothub_connection_str)

invoke_command_result = digital_twin_client.invoke_command(
    device_id, "getMaxMinReport", payload, connect_timeout_in_seconds, response_timeout_in_seconds
)
if invoke_command_result:
    print(invoke_command_result)
else:
    print("No invoke_command_result found")

Följande kodfragment visar hur du anropar getMaxMinReport kommandot på en komponent. Kommandot definieras i termostat1-komponenten :

from azure.iot.hub import DigitalTwinClient

payload = datetime.datetime.now() - datetime.timedelta(minutes=2)

connect_timeout_in_seconds = 3
response_timeout_in_seconds = 7


digital_twin_client = DigitalTwinClient(iothub_connection_str)

invoke_command_result = digital_twin_client.invoke_component_command(
    device_id, "thermostat1", "getMaxMinReport", payload, connect_timeout_in_seconds, response_timeout_in_seconds
)
if invoke_command_result:
    print(invoke_command_result)
else:
    print("No invoke_command_result found")

Läsa enhetstelemetri

IoT Plug and Play-enheter skickar telemetrin som definierats i DTDL-modellen till IoT Hub. Som standard dirigerar IoT Hub telemetrin till en Event Hubs-slutpunkt där du kan använda den. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till moln till olika slutpunkter.

Följande kodfragment visar hur du läser telemetrin från standardslutpunkten för Event Hubs. Koden i det här kodfragmentet hämtas från snabbstarten för IoT Hub Skicka telemetri från en enhet till en IoT-hubb och läs den med ett serverdelsprogram:

import asyncio
from azure.eventhub import TransportType
from azure.eventhub.aio import EventHubConsumerClient

# Define callbacks to process events
async def on_event_batch(partition_context, events):
    for event in events:
        print("Received event from partition: {}.".format(partition_context.partition_id))
        print("Telemetry received: ", event.body_as_str())
        print("Properties (set by device): ", event.properties)
        print("System properties (set by IoT Hub): ", event.system_properties)
        print()
    await partition_context.update_checkpoint()

async def on_error(partition_context, error):
    # ...

loop = asyncio.get_event_loop()
client = EventHubConsumerClient.from_connection_string(
    conn_str=CONNECTION_STR,
    consumer_group="$default",
)

try:
    loop.run_until_complete(client.receive_batch(on_event_batch=on_event_batch, on_error=on_error))
except KeyboardInterrupt:
    print("Receiving has stopped.")
finally:
    loop.run_until_complete(client.close())
    loop.stop()

Följande utdata från föregående kod visar temperaturtelemetrin som skickas av termostat-IoT Plug and Play-enheten utan komponent som bara har standardkomponenten. Systemegenskapen dt-dataschema visar modell-ID:

Received event from partition: 1.
Telemetry received:  {"temperature": 12}
Properties (set by device):  None
System properties (set by IoT Hub):  {b'content-type': b'application/json', b'content-encoding': b'utf-8', b'iothub-connection-device-id': b'my-pnp-device', b'iothub-connection-auth-method': b'{"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}', b'iothub-connection-auth-generation-id': b'637388855582764406', b'iothub-enqueuedtime': 1603288810715, b'iothub-message-source': b'Telemetry', b'dt-dataschema': b'dtmi:com:example:Thermostat;1', b'x-opt-sequence-number': 13280, b'x-opt-offset': b'12890070640', b'x-opt-enqueued-time': 1603288810824}

Följande utdata från föregående kod visar den temperaturtelemetri som skickas av multikomponenten TemperatureController IoT Plug and Play-enheten. Systemegenskapen dt-subject visar namnet på komponenten som skickade telemetrin. I det här exemplet är thermostat1 de två komponenterna och thermostat2 enligt definitionen i DTDL-modellen. Systemegenskapen dt-dataschema visar modell-ID:

Received event from partition: 1.
Telemetry received:  {"temperature": 45}
Properties (set by device):  None
System properties (set by IoT Hub):  {b'content-type': b'application/json', b'content-encoding': b'utf-8', b'iothub-connection-device-id': b'my-pnp-device', b'iothub-connection-auth-method': b'{"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}', b'iothub-connection-auth-generation-id': b'637388858939631652', b'iothub-enqueuedtime': 1603289127844, b'iothub-message-source': b'Telemetry', b'dt-subject': b'thermostat1', b'dt-dataschema': b'dtmi:com:example:TemperatureController;1', b'x-opt-sequence-number': 13328, b'x-opt-offset': b'12890095440', b'x-opt-enqueued-time': 1603289128001}

Received event from partition: 1.
Telemetry received:  {"temperature": 49}
Properties (set by device):  None
System properties (set by IoT Hub):  {b'content-type': b'application/json', b'content-encoding': b'utf-8', b'iothub-connection-device-id': b'my-pnp-device', b'iothub-connection-auth-method': b'{"scope":"device","type":"sas","issuer":"iothub","acceptingIpFilterRule":null}', b'iothub-connection-auth-generation-id': b'637388858939631652', b'iothub-enqueuedtime': 1603289133017, b'iothub-message-source': b'Telemetry', b'dt-subject': b'thermostat2', b'dt-dataschema': b'dtmi:com:example:TemperatureController;1', b'x-opt-sequence-number': 13329, b'x-opt-offset': b'12890095928', b'x-opt-enqueued-time': 1603289133173}

Läsa meddelanden om ändring av enhetstvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om enhetstvillingändringar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående Python-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om ändring av enhetstvillingar för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Received event from partition: 1.
Telemetry received:  {"version":3,"properties":{"reported":{"maxTempSinceLastReboot":10.96,"$metadata":{"$lastUpdated":"2020-10-21T14:10:42.4171263Z","maxTempSinceLastReboot":{"$lastUpdated":"2020-10-21T14:10:42.4171263Z"}},"$version":2}}}
Properties (set by device):  {b'hubName': b'my-pnp-hub', b'deviceId': b'my-pnp-device', b'operationTimestamp': b'2020-10-21T14:10:42.4171263+00:00', b'iothub-message-schema': b'twinChangeNotification', b'opType': b'updateTwin'}
System properties (set by IoT Hub):  {b'user-id': b'my-pnp-hub\x81\x0e\xa4\x7f', b'correlation-id': b'12104ced5402', b'content-type': b'application/json', b'content-encoding': b'utf-8', b'iothub-connection-device-id': b'my-pnp-device', b'iothub-enqueuedtime': 1603289442519, b'iothub-message-source': b'twinChangeEvents', b'x-opt-sequence-number': 13332, b'x-opt-offset': b'12890097392', b'x-opt-enqueued-time': 1603289442738}

Koden som visas i föregående Python-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om enhetstvillingändring för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Received event from partition: 1.
Telemetry received:  {"version":4,"properties":{"reported":{"thermostat1":{"maxTempSinceLastReboot":98.34,"__t":"c"},"$metadata":{"$lastUpdated":"2020-10-21T14:13:39.36491Z","thermostat1":{"$lastUpdated":"2020-10-21T14:13:39.36491Z","maxTempSinceLastReboot":{"$lastUpdated":"2020-10-21T14:13:39.36491Z"},"__t":{"$lastUpdated":"2020-10-21T14:13:39.36491Z"}}},"$version":3}}}
Properties (set by device):  {b'hubName': b'my-pnp-hub', b'deviceId': b'my-pnp-device', b'operationTimestamp': b'2020-10-21T14:13:39.3649100+00:00', b'iothub-message-schema': b'twinChangeNotification', b'opType': b'updateTwin'}
System properties (set by IoT Hub):  {b'user-id': b'my-pnp-hub', b'correlation-id': b'1210b664ab83', b'content-type': b'application/json', b'content-encoding': b'utf-8', b'iothub-connection-device-id': b'my-pnp-device', b'iothub-enqueuedtime': 1603289619481, b'iothub-message-source': b'twinChangeEvents', b'x-opt-sequence-number': 13341, b'x-opt-offset': b'12890102216', b'x-opt-enqueued-time': 1603289619668}

Läsa meddelanden om ändring av digitala tvillingar

Du kan konfigurera IoT Hub för att generera meddelanden om ändring av digitala tvillingar för att dirigera till en slutpunkt som stöds. Mer information finns i Använda IoT Hub-meddelanderoutning för att skicka meddelanden från enhet till molnet till olika slutpunkter > – icke-telemetrihändelser.

Koden som visas i föregående Python-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om ändring av digitala tvillingar för en termostatenhet utan komponent. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Received event from partition: 1.
Telemetry received:  [{"op":"add","path":"/$metadata/maxTempSinceLastReboot","value":{"lastUpdateTime":"2020-10-21T14:10:42.4171263Z"}},{"op":"add","path":"/maxTempSinceLastReboot","value":10.96}]
Properties (set by device):  {b'hubName': b'my-pnp-hub', b'deviceId': b'my-pnp-device', b'operationTimestamp': b'2020-10-21T14:10:42.4171263+00:00', b'iothub-message-schema': b'digitalTwinChangeNotification', b'opType': b'updateTwin'}
System properties (set by IoT Hub):  {b'user-id': b'my-pnp-hub\x81\x0e\xa4\x7f', b'correlation-id': b'12104ced5402', b'content-type': b'application/json-patch+json', b'content-encoding': b'utf-8', b'iothub-connection-device-id': b'my-pnp-device', b'iothub-enqueuedtime': 1603289442519, b'iothub-message-source': b'digitalTwinChangeEvents', b'x-opt-sequence-number': 13333, b'x-opt-offset': b'12890098024', b'x-opt-enqueued-time': 1603289442738}

Koden som visas i föregående Python-kodfragment genererar följande utdata när IoT Hub genererar meddelanden om digital tvillingändring för en enhet med komponenter. Det här exemplet visar utdata när en temperatursensorenhet med en termostatkomponent genererar meddelanden. Programmets egenskaper iothub-message-schema och opType ger dig information om typen av ändringsmeddelande:

Received event from partition: 1.
Telemetry received:  [{"op":"add","path":"/thermostat1","value":{"$metadata":{"maxTempSinceLastReboot":{"lastUpdateTime":"2020-10-21T14:13:39.36491Z"}},"maxTempSinceLastReboot":98.34}}]
Properties (set by device):  {b'hubName': b'my-pnp-hub', b'deviceId': b'my-pnp-device', b'operationTimestamp': b'2020-10-21T14:13:39.3649100+00:00', b'iothub-message-schema': b'digitalTwinChangeNotification', b'opType': b'updateTwin'}
System properties (set by IoT Hub):  {b'user-id': b'my-pnp-hub', b'correlation-id': b'1210b664ab83', b'content-type': b'application/json-patch+json', b'content-encoding': b'utf-8', b'iothub-connection-device-id': b'my-pnp-device', b'iothub-enqueuedtime': 1603289619481, b'iothub-message-source': b'digitalTwinChangeEvents', b'x-opt-sequence-number': 13342, b'x-opt-offset': b'12890102984', b'x-opt-enqueued-time': 1603289619668}

Nästa steg

Nu när du har lärt dig om enhetsmodellering finns här några fler resurser:

• Digital Twins Definition Language (DTDL)
• C-enhets-SDK
• IoT REST API
• Modelleringsguide för IoT Plug and Play