Ontwikkelaarshandleiding voor IoT Plug en Play-service

  • Artikel

Met IoT Plug en Play kunt u IoT-apparaten bouwen die hun mogelijkheden adverteren naar Azure IoT-toepassingen. Voor IoT-Plug en Play-apparaten is geen handmatige configuratie vereist wanneer een klant deze verbindt met IoT Plug en Play-toepassingen.

Met IoT Plug en Play kunt u apparaten gebruiken die hun model-id hebben aangekondigd met uw IoT-hub. U hebt bijvoorbeeld rechtstreeks toegang tot de eigenschappen en opdrachten van een apparaat.

Als u IoT Central gebruikt, kunt u de gebruikersinterface en REST API van IoT Central gebruiken om te communiceren met IoT Plug en Play apparaten die zijn verbonden met uw toepassing.

Service-SDK's

Gebruik de SDK's van de Azure IoT-service in uw oplossing om te communiceren met apparaten en modules. U kunt bijvoorbeeld de service-SDK's gebruiken om eigenschappen van dubbels te lezen en bij te werken en opdrachten aan te roepen. Ondersteunde talen zijn C#, Java, Node.js en Python.

De SDK's van de Azure IoT-service bevatten code om toepassingen te bouwen die rechtstreeks met IoT Hub communiceren om apparaten en beveiliging te beheren.

Platform Pakket Codeopslagplaats Voorbeelden Verwijzing
.NET NuGet GitHub Voorbeelden Verwijzing
Java Maven GitHub Voorbeelden Verwijzing
Knooppunt npm GitHub Voorbeelden Verwijzing
Python Pip GitHub Voorbeelden Verwijzing

Met de service-SDK's hebt u toegang tot apparaatgegevens vanuit een oplossingsonderdeel, zoals een bureaublad- of webtoepassing. De service-SDK's bevatten twee naamruimten en objectmodellen die u kunt gebruiken om de model-id op te halen:

  • IoT Hub-serviceclient. Met deze service wordt de model-id weergegeven als een eigenschap van een apparaatdubbel.

  • Digital Twins-client. De nieuwe Digital Twins-API werkt op DTDL-modelconstructies (Digital Twins Definition Language), zoals onderdelen, eigenschappen en opdrachten. De Digital Twin-API's maken het eenvoudiger voor ontwikkelaars van oplossingen om IoT-Plug en Play-oplossingen te maken.

De volgende resources zijn ook beschikbaar:

Voorbeelden van IoT Hub-serviceclients

In deze sectie ziet u C#-voorbeelden met behulp van de IoT Hub-serviceclient en de klassen RegistryManager en ServiceClient . U gebruikt de Klasse RegistryManager om te communiceren met de apparaatstatus met behulp van apparaatdubbels. U kunt ook de RegistryManager-klasse gebruiken om een query uit te voeren op apparaatregistraties in uw IoT Hub. U gebruikt de ServiceClient-klasse om opdrachten op het apparaat aan te roepen. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert. In de codefragmenten bevat de deviceTwinId variabele de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De apparaatdubbel en model-id ophalen

De apparaatdubbel en model-id ophalen van het IoT-Plug en Play-apparaat dat is verbonden met uw IoT-hub:

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

Apparaatdubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. In het voorbeeld ziet u hoe u de tweeling ETag moet ophalen voordat u deze bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. In het voorbeeld ziet u hoe u de tweeling ETag moet ophalen voordat u deze bijwerkt. De eigenschap is gedefinieerd in het onderdeel Thermostat1 :

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

Voor een eigenschap in een onderdeel ziet de eigenschapspatch eruit als in het volgende voorbeeld:

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

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het onderdeel Thermostat1 :

// 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.");
}

Voorbeelden van digitale dubbels in IoT Hub

U gebruikt de DigitalTwinClient-klasse om te communiceren met de apparaatstatus met behulp van digitale dubbels. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert.

In deze sectie ziet u C#-voorbeelden met behulp van de Digital Twins-API. De volgende codefragmenten gebruiken de volgende klassen om de digitale dubbel van de thermostaat- en temperatuurcontrollerapparaten weer te geven:

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

De digitalTwinId variabele bevat de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De digitale dubbel en model-id ophalen

De digitale dubbel en model-id van het IoT-Plug en Play-apparaat ophalen dat is verbonden met uw IoT-hub:

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

Digitale dubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. De eigenschap is gedefinieerd in het onderdeel Thermostat1 :

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

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het onderdeel Thermostat1 :

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

Telemetrie van apparaten lezen

IoT-Plug en Play-apparaten verzenden de telemetrie die is gedefinieerd in het DTDL-model naar IoT Hub. Standaard stuurt IoT Hub de telemetrie naar een Event Hubs-eindpunt waar u deze kunt gebruiken. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten naar verschillende eindpunten te verzenden voor meer informatie.

In het volgende codefragment ziet u hoe u de telemetrie kunt lezen van het standaard-Event Hubs-eindpunt. De code in dit codefragment wordt opgehaald uit de quickstart ioT Hub: telemetrie verzenden van een apparaat naar een IoT-hub en lezen met een back-endtoepassing:

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

In de volgende uitvoer van de vorige code ziet u de temperatuurtelemetrie die is verzonden door het IoT-Plug en Play-apparaat zonder onderdelen dat alleen het standaardonderdeel heeft. De dt-dataschema systeemeigenschap toont de model-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

In de volgende uitvoer van de vorige code ziet u de temperatuurtelemetrie die door het IoT-Plug en Play-apparaat met meerdere onderdelen wordt verzonden. De dt-subject systeemeigenschap toont de naam van het onderdeel dat de telemetrie heeft verzonden. In dit voorbeeld zijn de twee onderdelen en thermostat1thermostat2 zoals gedefinieerd in het DTDL-model. De dt-dataschema systeemeigenschap toont de model-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

Meldingen over wijziging van apparaatdubbels lezen

U kunt IoT Hub configureren om meldingen voor apparaatdubbels te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die in het vorige C#-codefragment wordt weergegeven, genereert de volgende uitvoer wanneer IoT Hub meldingen over apparaatdubbels voor een thermostaat zonder onderdelen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

De code die wordt weergegeven in het vorige C#-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over apparaatdubbels voor een apparaat met onderdelen genereert. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

Meldingen over wijziging van digitale dubbels lezen

U kunt IoT Hub configureren om meldingen voor digitale dubbelwijzigingen te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die in het vorige C#-codefragment wordt weergegeven, genereert de volgende uitvoer wanneer IoT Hub meldingen voor digitale dubbelwijzigingen genereert voor een thermostaat zonder onderdelen. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

De code die in het vorige C#-codefragment wordt weergegeven, genereert de volgende uitvoer wanneer IoT Hub meldingen voor digitale dubbelwijzigingen genereert voor een apparaat met onderdelen. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

De volgende resources zijn ook beschikbaar:

Voorbeelden van IoT Hub-serviceclients

In deze sectie vindt u Java-voorbeelden met behulp van de IoT Hub-serviceclient en de klassen DeviceTwin en DeviceMethod van de naamruimte com.microsoft.azure.sdk.iot.service.devicetwin . U gebruikt de DeviceTwin-klasse om te communiceren met de apparaatstatus met behulp van apparaatdubbels. U kunt ook de DeviceTwin-klasse gebruiken om een query uit te voeren op apparaatregistraties in uw IoT Hub. U gebruikt de klasse DeviceMethod om opdrachten op het apparaat aan te roepen. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert. In de codefragmenten bevat de deviceId variabele de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De apparaatdubbel en model-id ophalen

De apparaatdubbel en model-id ophalen van het IoT-Plug en Play-apparaat dat is verbonden met uw IoT-hub:

DeviceTwin twinClient = DeviceTwin.createFromConnectionString(iotHubConnectionString);

// ...

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

Apparaatdubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. U moet de tweeling ophalen voordat u deze bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. U moet de tweeling ophalen voordat u deze bijwerkt. De eigenschap is gedefinieerd in het thermostaat1-onderdeel :

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

Voor een eigenschap in een onderdeel ziet de eigenschapspatch eruit als in het volgende voorbeeld:

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

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het thermostaat1-onderdeel :

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

Voorbeelden van digitale dubbels in IoT Hub

U gebruikt de klasse DigitalTwinAsyncClient in de com.microsoft.azure.sdk.iot.service.digitaltwin-naamruimte om te communiceren met de apparaatstatus met behulp van digital twins. In de volgende voorbeelden worden ook de klassen UpdateOperationUtility en BasicDigitalTwin uit dezelfde naamruimte gebruikt. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert.

De digitalTwinid variabele bevat de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De digitale dubbel en model-id ophalen

De digitale dubbel en model-id van het IoT-Plug en Play-apparaat ophalen dat is verbonden met uw IoT-hub:

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

Digitale dubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. De eigenschap is gedefinieerd in het thermostaat1-onderdeel :

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

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het thermostaat1-onderdeel :

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

Telemetrie van apparaten lezen

IoT-Plug en Play-apparaten verzenden de telemetrie die is gedefinieerd in het DTDL-model naar IoT Hub. Standaard stuurt IoT Hub de telemetrie naar een Event Hubs-eindpunt waar u deze kunt gebruiken. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten naar verschillende eindpunten te verzenden voor meer informatie.

In het volgende codefragment ziet u hoe u de telemetrie kunt lezen van het standaard-Event Hubs-eindpunt. De code in dit codefragment wordt opgehaald uit de quickstart ioT Hub: telemetrie verzenden van een apparaat naar een IoT-hub en lezen met een back-endtoepassing:

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

In de volgende uitvoer van de vorige code ziet u de temperatuurtelemetrie die is verzonden door het IoT-Plug en Play-apparaat zonder onderdelen dat alleen het standaardonderdeel heeft. De dt-dataschema systeemeigenschap toont de model-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=dd960185-6ddb-4b5f-89bb-e26b0b3c201e, 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=1c05cece-070b-4e2e-b2e8-e263858594a3, 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=d10a7350-43ef-4cf6-9db5-a4b08684cd9d, 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=d3a80af4-1246-41a0-a09a-582a12c17a00, content-type=application/json}

In de volgende uitvoer van de vorige code ziet u de temperatuurtelemetrie die door het IoT-Plug en Play-apparaat met meerdere onderdelen wordt verzonden. De dt-subject systeemeigenschap toont de naam van het onderdeel dat de telemetrie heeft verzonden. In dit voorbeeld zijn de twee onderdelen en thermostat1thermostat2 zoals gedefinieerd in het DTDL-model. De dt-dataschema systeemeigenschap toont de model-id:

Telemetry received from partition 1:
null
Application properties (set by device):
{$.cdid=my-pnp-device}
System properties (set by IoT Hub):
{correlation-id=413002d0-2107-4c08-8f4a-995ae1f4047b, 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=da8bd068-850e-43fb-862f-66080d5969e4, 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=2d9407e5-413f-4f8d-bd30-cd153e03c72f, 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=ed419c4e-ef2c-4acf-8991-6245059c5fdc, content-type=application/json, dt-subject=thermostat2}

Meldingen over wijziging van apparaatdubbels lezen

U kunt IoT Hub configureren om meldingen voor apparaatdubbels te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die wordt weergegeven in het vorige Java-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over wijzigingsmeldingen voor apparaatdubbels genereert voor een thermostaat zonder onderdelen. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

De code die wordt weergegeven in het vorige Java-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over wijzigingsmeldingen voor apparaatdubbels genereert voor een apparaat met onderdelen. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

Meldingen over wijziging van digitale dubbels lezen

U kunt IoT Hub configureren om meldingen voor digitale dubbelwijzigingen te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die wordt weergegeven in het vorige Java-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen voor digitale dubbelwijzigingen genereert voor een thermostaat zonder onderdelen. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

De code die wordt weergegeven in het vorige Java-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over digitale dubbelwijzigingen genereert voor een apparaat met onderdelen. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

De volgende resources zijn ook beschikbaar:

Voorbeelden van IoT Hub-serviceclients

In deze sectie worden JavaScript-voorbeelden getoond met behulp van de IoT Hub-serviceclient en de register- en clientklassen. U gebruikt de registerklasse om te communiceren met de apparaatstatus met behulp van apparaatdubbels. U kunt ook de registerklasse gebruiken om een query uit te voeren op apparaatregistraties in uw IoT Hub. U gebruikt de clientklasse om opdrachten op het apparaat aan te roepen. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert. In de codefragmenten bevat de deviceId variabele de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De apparaatdubbel en model-id ophalen

De apparaatdubbel en model-id ophalen van het IoT-Plug en Play-apparaat dat is verbonden met uw IoT-hub:

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

Apparaatdubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. In het voorbeeld ziet u hoe u de dubbel moet ophalen voordat u deze bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. In het voorbeeld ziet u hoe u de dubbel moet ophalen voordat u deze bijwerkt. De eigenschap is gedefinieerd in het thermostaat1-onderdeel :

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

Voor een eigenschap in een onderdeel ziet de eigenschapspatch eruit als in het volgende voorbeeld:

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

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het thermostaat1-onderdeel :

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

Voorbeelden van digitale dubbels in IoT Hub

U gebruikt de DigitalTwinClient-klasse om te communiceren met de apparaatstatus met behulp van digitale dubbels. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert.

In deze sectie ziet u JavaScript-voorbeelden met behulp van de Digital Twins-API.

De digitalTwinId variabele bevat de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De digitale dubbel en model-id ophalen

De digitale dubbel en model-id van het IoT-Plug en Play-apparaat ophalen dat is verbonden met uw IoT-hub:

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

Digitale dubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. De eigenschap is gedefinieerd in het thermostaat1-onderdeel :

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

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het thermostaat1-onderdeel :

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

Telemetrie van apparaten lezen

IoT-Plug en Play-apparaten verzenden de telemetrie die is gedefinieerd in het DTDL-model naar IoT Hub. Standaard stuurt IoT Hub de telemetrie naar een Event Hubs-eindpunt waar u deze kunt gebruiken. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten naar verschillende eindpunten te verzenden voor meer informatie.

In het volgende codefragment ziet u hoe u de telemetrie kunt lezen van het standaard-Event Hubs-eindpunt. De code in dit codefragment wordt opgehaald uit de quickstart ioT Hub: telemetrie verzenden van een apparaat naar een IoT-hub en lezen met een back-endtoepassing:

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

In de volgende uitvoer van de vorige code ziet u de temperatuurtelemetrie die door het IoT-Plug en Play-apparaat met meerdere onderdelen wordt verzonden. De dt-subject systeemeigenschap toont de naam van het onderdeel dat de telemetrie heeft verzonden. In dit voorbeeld zijn de twee onderdelen en thermostat1thermostat2 zoals gedefinieerd in het DTDL-model. De dt-dataschema systeemeigenschap toont de model-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"}

Meldingen over wijziging van apparaatdubbels lezen

U kunt IoT Hub configureren om meldingen voor apparaatdubbels te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die wordt weergegeven in het vorige JavaScript-codefragment genereert de volgende uitvoer wanneer IoT Hub wijzigingsmeldingen voor apparaatdubbel genereert voor een thermostaat zonder onderdelen. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

De code die wordt weergegeven in het vorige JavaScript-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over apparaatdubbels voor een apparaat met onderdelen genereert. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

Meldingen over wijziging van digitale dubbels lezen

U kunt IoT Hub configureren om meldingen voor digitale dubbelwijzigingen te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die wordt weergegeven in het vorige JavaScript-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen voor digitale dubbelwijzigingen genereert voor een thermostaat zonder onderdelen. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

De code die wordt weergegeven in het vorige JavaScript-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen voor digitale dubbelwijzigingen genereert voor een apparaat met onderdelen. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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

De volgende resources zijn ook beschikbaar:

Voorbeelden van IoT Hub-serviceclients

In deze sectie ziet u Python-voorbeelden met behulp van de IoT Hub-serviceclient en de klassen IoTHubRegistryManager en CloudToDeviceMethod . U gebruikt de IoTHubRegistryManager-klasse om te communiceren met de apparaatstatus met behulp van apparaatdubbels. U kunt ook de klasse IoTHubRegistryManager gebruiken om apparaatregistraties in uw IoT Hub op te vragen. U gebruikt de klasse CloudToDeviceMethod om opdrachten op het apparaat aan te roepen. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert. In de codefragmenten bevat de device_id variabele de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De apparaatdubbel en model-id ophalen

De apparaatdubbel en model-id ophalen van het IoT-Plug en Play-apparaat dat is verbonden met uw IoT-hub:

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("")

Apparaatdubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. In het voorbeeld ziet u hoe u de tweeling etag moet ophalen voordat u deze bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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)

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. In het voorbeeld ziet u hoe u de tweeling ETag moet ophalen voordat u deze bijwerkt. De eigenschap is gedefinieerd in het thermostaat1-onderdeel :

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)

Voor een eigenschap in een onderdeel ziet de eigenschapspatch eruit als in het volgende voorbeeld:

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

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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)

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het thermostaat1-onderdeel :

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)

Voorbeelden van digitale dubbels in IoT Hub

U gebruikt de DigitalTwinClient-klasse om te communiceren met de apparaatstatus met behulp van digitale dubbels. Het DTDL-model voor het apparaat definieert de eigenschappen en opdrachten die het apparaat implementeert.

De device_id variabele bevat de apparaat-id van het IoT-Plug en Play-apparaat dat is geregistreerd bij uw IoT-hub.

De digitale dubbel en model-id ophalen

De digitale dubbel en model-id van het IoT-Plug en Play-apparaat ophalen dat is verbonden met uw IoT-hub:

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

Digitale dubbel bijwerken

Het volgende codefragment laat zien hoe u de targetTemperature eigenschap op een apparaat bijwerkt. De eigenschap wordt gedefinieerd in het standaardonderdeel van het apparaat:

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)

In het volgende fragment ziet u hoe u de targetTemperature eigenschap voor een onderdeel bijwerkt. De eigenschap is gedefinieerd in het thermostaat1-onderdeel :

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)

Opdracht Aanroepen

Het volgende codefragment laat zien hoe u de getMaxMinReport opdracht aanroept die is gedefinieerd in een standaardonderdeel:

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

In het volgende fragment ziet u hoe u de getMaxMinReport opdracht aanroept voor een onderdeel. De opdracht wordt gedefinieerd in het thermostaat1-onderdeel :

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

Telemetrie van apparaten lezen

IoT-Plug en Play-apparaten verzenden de telemetrie die is gedefinieerd in het DTDL-model naar IoT Hub. Standaard stuurt IoT Hub de telemetrie naar een Event Hubs-eindpunt waar u deze kunt gebruiken. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten naar verschillende eindpunten te verzenden voor meer informatie.

In het volgende codefragment ziet u hoe u de telemetrie kunt lezen van het standaard-Event Hubs-eindpunt. De code in dit codefragment wordt opgehaald uit de quickstart ioT Hub: telemetrie verzenden van een apparaat naar een IoT-hub en lezen met een back-endtoepassing:

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

In de volgende uitvoer van de vorige code ziet u de temperatuurtelemetrie die is verzonden door het IoT-Plug en Play-apparaat zonder onderdelen dat alleen het standaardonderdeel heeft. De dt-dataschema systeemeigenschap toont de model-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}

In de volgende uitvoer van de vorige code ziet u de temperatuurtelemetrie die door het IoT-Plug en Play-apparaat met meerdere onderdelen wordt verzonden. De dt-subject systeemeigenschap toont de naam van het onderdeel dat de telemetrie heeft verzonden. In dit voorbeeld zijn de twee onderdelen en thermostat1thermostat2 zoals gedefinieerd in het DTDL-model. De dt-dataschema systeemeigenschap toont de model-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}

Meldingen over wijziging van apparaatdubbels lezen

U kunt IoT Hub configureren om meldingen voor apparaatdubbels te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die wordt weergegeven in het vorige Python-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over wijzigingsmeldingen voor apparaatdubbel genereert voor een thermostaat zonder onderdelen. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

Met de code die wordt weergegeven in het vorige Python-codefragment wordt de volgende uitvoer gegenereerd wanneer IoT Hub meldingen over apparaatdubbels voor een apparaat met onderdelen genereert. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

Meldingen over wijziging van digitale dubbels lezen

U kunt IoT Hub configureren om meldingen voor digitale dubbelwijzigingen te genereren om naar een ondersteund eindpunt te routeren. Zie IoT Hub-berichtroutering gebruiken om apparaat-naar-cloud-berichten te verzenden naar verschillende eindpunten, niet-telemetriegebeurtenissen>.

De code die wordt weergegeven in het vorige Python-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over digitale dubbelwijzigingen genereert voor een thermostaat zonder onderdelen. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

De code die wordt weergegeven in het vorige Python-codefragment genereert de volgende uitvoer wanneer IoT Hub meldingen over digitale dubbelwijzigingen genereert voor een apparaat met onderdelen. In dit voorbeeld ziet u de uitvoer wanneer een temperatuursensorapparaat met een thermostaatonderdeel meldingen genereert. De eigenschappen van de toepassing iothub-message-schema en opType geven u informatie over het type wijzigingsmelding:

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}

Volgende stappen

Nu u meer hebt geleerd over apparaatmodellering, vindt u hier nog enkele resources: