Az IoT Plug and Play szolgáltatás fejlesztői útmutatója
Az IoT Plug and Play lehetővé teszi olyan IoT-eszközök létrehozását, amelyek a képességeiket az Azure IoT-alkalmazásokban hirdetik. Az IoT Plug and Play-eszközök nem igényelnek manuális konfigurálást, ha egy ügyfél csatlakoztatja őket az IoT Plug and Play-kompatibilis alkalmazásokhoz.
Az IoT Plug and Play segítségével olyan eszközöket használhat, amelyek bejelentették a modellazonosítójukat az IoT Hubon. Egy eszköz tulajdonságait és parancsait például közvetlenül is elérheti.
Ha IoT Centralt használ, az IoT Central felhasználói felületével és a REST API-val kommunikálhat az alkalmazáshoz csatlakoztatott IoT Plug and Play-eszközökkel.
A megoldásban található Azure IoT szolgáltatás SDK-kkal kommunikálhat az eszközökkel és modulokkal. A szolgáltatás SDK-kkal például olvashatja és frissítheti az ikertulajdonságokat, és parancsokat hívhat meg. A támogatott nyelvek közé tartozik a C#, a Java, a Node.js és a Python.
Az Azure IoT service SDK-k kódokat tartalmaznak, amelyek megkönnyítik az IoT Hubtal közvetlenül kommunikáló alkalmazások létrehozását az eszközök és a biztonság kezelése érdekében.
Platform | Csomag | Kódtár | Példák | Referencia |
---|---|---|---|---|
.NET | NuGet | GitHub | Példák | Referencia |
Java | Maven | GitHub | Példák | Referencia |
Csomópont | npm | GitHub | Példák | Referencia |
Python | Pip | GitHub | Példák | Referencia |
A szolgáltatási SDK-k lehetővé teszik az eszközinformációk elérését egy megoldásösszetevőből, például egy asztali vagy webalkalmazásból. A szolgáltatás SDK-k két névteret és objektummodellt tartalmaznak, amelyekkel lekérheti a modellazonosítót:
Iot Hub szolgáltatásügyfél. Ez a szolgáltatás a modellazonosítót ikereszköz-tulajdonságként teszi elérhetővé.
Digital Twins-ügyfél. Az új Digital Twins API a Digital Twins Definition Language (DTDL) modellen működik, például összetevőket, tulajdonságokat és parancsokat. A Digital Twin API-k megkönnyítik a megoldáskészítők számára az IoT Plug and Play-megoldások létrehozását.
A következő erőforrások is elérhetők:
Ez a szakasz C#-példákat mutat be az IoT Hub szolgáltatásügyfél, valamint a RegistryManager és a ServiceClient osztályok használatával. A RegistryManager osztály használatával kezelheti az eszköz állapotát az ikereszközökkel. A RegistryManager osztály használatával is lekérdezheti az eszközregisztrációkat az IoT Hubon. A ServiceClient osztály használatával parancsokat hívhat meg az eszközön. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat. A kódrészletekben a változó az deviceTwinId
IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play-eszköz ikereszközének és modellazonosítójának lekérése:
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}.");
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A minta bemutatja, hogyan kell beszerezni az ikerpéldányt ETag
a frissítés előtt. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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);
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A minta bemutatja, hogyan kell beszerezni az ikerpéldányt ETag
a frissítés előtt. A tulajdonság a Thermostat1 összetevőben van definiálva:
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;
}
Egy összetevő tulajdonsága esetén a tulajdonságjavítás a következő példához hasonlóan néz ki:
{
"sampleComponentName":
{
"__t": "c",
"samplePropertyName": 20
}
}
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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}.";
}
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a Thermostat1 összetevőben van definiálva:
// 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.");
}
A DigitalTwinClient osztály használatával digitális ikerpéldányokkal kezelheti az eszköz állapotát. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat.
Ez a szakasz C#-példákat mutat be a Digital Twins API használatával. Az alábbi kódrészletek a termosztát és a hőmérséklet-vezérlő eszközök digitális ikerpéldányát ábrázolják:
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; }
}
}
A digitalTwinId
változó az IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play eszköz digitális iker- és modellazonosítójának lekérése:
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)}");
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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}.");
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A tulajdonság a Thermostat1 összetevőben van definiálva:
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}.");
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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}.");
}
}
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a Thermostat1 összetevőben van definiálva:
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.");
}
}
Az IoT Plug and Play-eszközök elküldik a DTDL-modellben meghatározott telemetriát az IoT Hubnak. Az IoT Hub alapértelmezés szerint átirányítja a telemetriát egy Event Hubs-végpontra, ahol felhasználhatja. További információ: Az IoT Hub üzenet-útválasztásának használata az eszközről a felhőbe irányuló üzenetek különböző végpontokra való küldéséhez.
Az alábbi kódrészlet bemutatja, hogyan olvashatja be a telemetriát az alapértelmezett Event Hubs-végpontról. Az ebben a kódrészletben található kód az IoT Hub rövid útmutatójából származik, amely telemetriát küld egy eszközről egy IoT Hubra, és egy háttéralkalmazással olvassa el:
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.
}
Az előző kód alábbi kimenete a nem komponensű Termosztát IoT Plug and Play eszköz által küldött hőmérséklet-telemetriát mutatja, amely csak az alapértelmezett összetevővel rendelkezik. A dt-dataschema
rendszertulajdonság a modellazonosítót jeleníti meg:
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
Az előző kód alábbi kimenete a többkomponensű TemperatureController IoT Plug and Play eszköz által küldött hőmérséklet-telemetriát mutatja. A dt-subject
rendszertulajdonság a telemetriát küldő összetevő nevét jeleníti meg. Ebben a példában a két összetevő a thermostat1
DTDL-modellben definiált és thermostat2
definiált. A dt-dataschema
rendszertulajdonság a modellazonosítót jeleníti meg:
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
Az IoT Hub konfigurálható úgy, hogy ikereszköz-változási értesítéseket hozzon létre, hogy egy támogatott végpontra irányítson. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző C# kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub ikereszköz-változási értesítéseket hoz létre egy nem összetevős termosztátos eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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
Az előző C# kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub az összetevőkkel rendelkező eszköz ikereszköz-változási értesítéseit hozza létre. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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
Az IoT Hub konfigurálható úgy, hogy digitális ikerpéldány-változási értesítéseket hozzon létre egy támogatott végpontra való átirányításhoz. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző C# kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre egy nem összetevős termosztátos eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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
Az előző C# kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre az összetevőket tartalmazó eszközhöz. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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
A következő erőforrások is elérhetők:
Ez a szakasz az IoT Hub szolgáltatásügyfél, valamint a com.microsoft.azure.sdk.iot.service.devicetwin névtér DeviceTwin és DeviceMethod osztályait használó Java-példákat mutatja be. A DeviceTwin osztály használatával kommunikálhat az eszköz állapotával az ikereszközök használatával. A DeviceTwin osztály használatával is lekérdezheti az eszközregisztrációkat az IoT Hubon. A DeviceMethod osztály használatával parancsokat hívhat meg az eszközön. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat. A kódrészletekben a változó az deviceId
IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play-eszköz ikereszközének és modellazonosítójának lekérése:
DeviceTwin twinClient = DeviceTwin.createFromConnectionString(iotHubConnectionString);
// ...
DeviceTwinDevice twin = new DeviceTwinDevice(deviceId);
twinClient.getTwin(twin);
System.out.println("Model Id of this Twin is: " + twin.getModelId());
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A frissítés előtt le kell szereznie az ikerpéldányt. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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);
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A frissítés előtt le kell szereznie az ikerpéldányt. A tulajdonság a termosztát1 összetevőben van definiálva:
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);
Egy összetevő tulajdonsága esetén a tulajdonságjavítás a következő példához hasonlóan néz ki:
{
"thermostat1":
{
"__t": "c",
"targetTemperature": 60.2
}
}
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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());
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a termosztát1 összetevőben van definiálva:
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());
A DigitalTwinAsyncClient osztályt a com.microsoft.azure.sdk.iot.service.digitaltwin névtérben használja az eszközállapot digitális ikerpéldányok használatával történő kezelésére. Az alábbi példák az UpdateOperationUtility és az BasicDigitalTwin osztályokat is használják ugyanabból a névtérből. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat.
A digitalTwinid
változó az IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play eszköz digitális iker- és modellazonosítójának lekérése:
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);
}
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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();
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A tulajdonság a termosztát1 összetevőben van definiálva:
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);
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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));
}
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a termosztát1 összetevőben van definiálva:
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));
}
Az IoT Plug and Play-eszközök elküldik a DTDL-modellben meghatározott telemetriát az IoT Hubnak. Az IoT Hub alapértelmezés szerint átirányítja a telemetriát egy Event Hubs-végpontra, ahol felhasználhatja. További információ: Az IoT Hub üzenet-útválasztásának használata az eszközről a felhőbe irányuló üzenetek különböző végpontokra való küldéséhez.
Az alábbi kódrészlet bemutatja, hogyan olvashatja be a telemetriát az alapértelmezett Event Hubs-végpontról. Az ebben a kódrészletben található kód az IoT Hub rövid útmutatójából származik, amely telemetriát küld egy eszközről egy IoT Hubra, és egy háttéralkalmazással olvassa el:
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");
});
}
Az előző kód alábbi kimenete a nem komponensű Termosztát IoT Plug and Play eszköz által küldött hőmérséklet-telemetriát mutatja, amely csak az alapértelmezett összetevővel rendelkezik. A dt-dataschema
rendszertulajdonság a modellazonosítót jeleníti meg:
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}
Az előző kód alábbi kimenete a többkomponensű TemperatureController IoT Plug and Play eszköz által küldött hőmérséklet-telemetriát mutatja. A dt-subject
rendszertulajdonság a telemetriát küldő összetevő nevét jeleníti meg. Ebben a példában a két összetevő a thermostat1
DTDL-modellben definiált és thermostat2
definiált. A dt-dataschema
rendszertulajdonság a modellazonosítót jeleníti meg:
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}
Az IoT Hub konfigurálható úgy, hogy ikereszköz-változási értesítéseket hozzon létre, hogy egy támogatott végpontra irányítson. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző Java-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub ikereszköz-változási értesítéseket hoz létre egy nem összetevős termosztátos eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
Az előző Java-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub ikereszköz-változási értesítéseket hoz létre egy összetevőt tartalmazó eszközhöz. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
Az IoT Hub konfigurálható úgy, hogy digitális ikerpéldány-változási értesítéseket hozzon létre egy támogatott végpontra való átirányításhoz. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző Java-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre egy nem összetevő alapú termosztát-eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
Az előző Java-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre egy összetevőket tartalmazó eszközhöz. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
A következő erőforrások is elérhetők:
Ez a szakasz JavaScript-példákat mutat be az IoT Hub szolgáltatásügyfél, valamint a beállításjegyzék és az ügyfélosztályok használatával. A Beállításjegyzék-osztály használatával kommunikálhat az eszközállapottal az ikereszközökkel. A Beállításjegyzék osztály használatával is lekérdezheti az eszközregisztrációkat az IoT Hubon. Az ügyfélosztály használatával parancsokat hívhat meg az eszközön. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat. A kódrészletekben a változó az deviceId
IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play-eszköz ikereszközének és modellazonosítójának lekérése:
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));
}
}
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A minta bemutatja, hogyan kell beszerezni az ikerpéldányt a frissítés előtt. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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));
}
}
}
}
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A minta bemutatja, hogyan kell beszerezni az ikerpéldányt a frissítés előtt. A tulajdonság a termosztát1 összetevőben van definiálva:
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));
}
}
}
}
Egy összetevő tulajdonsága esetén a tulajdonságjavítás a következő példához hasonlóan néz ki:
{
"thermostat1":
{
"__t": "c",
"targetTemperature": 20
}
}
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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));
}
});
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a termosztát1 összetevőben van definiálva:
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));
}
});
A DigitalTwinClient osztály használatával digitális ikerpéldányokkal kezelheti az eszköz állapotát. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat.
Ez a szakasz JavaScript-példákat mutat be a Digital Twins API használatával.
A digitalTwinId
változó az IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play eszköz digitális iker- és modellazonosítójának lekérése:
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));
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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);
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A tulajdonság a termosztát1 összetevőben van definiálva:
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);
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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));
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a termosztát1 összetevőben van definiálva:
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));
Az IoT Plug and Play-eszközök elküldik a DTDL-modellben meghatározott telemetriát az IoT Hubnak. Az IoT Hub alapértelmezés szerint átirányítja a telemetriát egy Event Hubs-végpontra, ahol felhasználhatja. További információ: Az IoT Hub üzenet-útválasztásának használata az eszközről a felhőbe irányuló üzenetek különböző végpontokra való küldéséhez.
Az alábbi kódrészlet bemutatja, hogyan olvashatja be a telemetriát az alapértelmezett Event Hubs-végpontról. Az ebben a kódrészletben található kód az IoT Hub rövid útmutatójából származik, amely telemetriát küld egy eszközről egy IoT Hubra, és egy háttéralkalmazással olvassa el:
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,
});
Az előző kód alábbi kimenete a többkomponensű TemperatureController IoT Plug and Play eszköz által küldött hőmérséklet-telemetriát mutatja. A dt-subject
rendszertulajdonság a telemetriát küldő összetevő nevét jeleníti meg. Ebben a példában a két összetevő a thermostat1
DTDL-modellben definiált és thermostat2
definiált. A dt-dataschema
rendszertulajdonság a modellazonosítót jeleníti meg:
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"}
Az IoT Hub konfigurálható úgy, hogy ikereszköz-változási értesítéseket hozzon létre, hogy egy támogatott végpontra irányítson. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző JavaScript-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub ikereszköz-változási értesítéseket hoz létre egy nem összetevős termosztátos eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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"}
Az előző JavaScript-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub ikereszköz-változási értesítéseket hoz létre egy összetevőt tartalmazó eszközhöz. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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"}
Az IoT Hub konfigurálható úgy, hogy digitális ikerpéldány-változási értesítéseket hozzon létre egy támogatott végpontra való átirányításhoz. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző JavaScript-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre egy nem összetevő alapú termosztát-eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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"}
Az előző JavaScript-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre egy összetevőt tartalmazó eszközhöz. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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"}
A következő erőforrások is elérhetők:
Ez a szakasz az IoT Hub szolgáltatásügyfél, valamint az IoTHubRegistryManager és a CloudToDeviceMethod osztályokat használó Python-példákat mutatja be. Az IoTHubRegistryManager osztály használatával kezelheti az eszköz állapotát az ikereszközökkel. Az IoTHubRegistryManager osztály használatával is lekérdezheti az eszközregisztrációkat az IoT Hubon. A CloudToDeviceMethod osztály használatával parancsokat hívhat meg az eszközön. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat. A kódrészletekben a változó az device_id
IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play-eszköz ikereszközének és modellazonosítójának lekérése:
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("")
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A minta bemutatja, hogyan kell beszerezni az ikerpéldányt etag
a frissítés előtt. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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)
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A minta bemutatja, hogyan kell beszerezni az ikerpéldányt ETag
a frissítés előtt. A tulajdonság a termosztát1 összetevőben van definiálva:
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)
Egy összetevő tulajdonsága esetén a tulajdonságjavítás a következő példához hasonlóan néz ki:
{
"thermostat1":
{
"__t": "c",
"targetTemperature": 20
}
}
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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)
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a termosztát1 összetevőben van definiálva:
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)
A DigitalTwinClient osztály használatával digitális ikerpéldányokkal kezelheti az eszköz állapotát. Az eszköz DTDL-modellje határozza meg az eszköz által implementált tulajdonságokat és parancsokat.
A device_id
változó az IoT Hubon regisztrált IoT Plug and Play-eszköz eszközazonosítóját tartalmazza.
Az IoT Hubhoz csatlakoztatott IoT Plug and Play eszköz digitális iker- és modellazonosítójának lekérése:
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")
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy eszközön. A tulajdonság az eszköz alapértelmezett összetevőjében van definiálva:
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)
Az alábbi kódrészlet bemutatja, hogyan frissítheti a targetTemperature
tulajdonságot egy összetevőn. A tulajdonság a termosztát1 összetevőben van definiálva:
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)
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg az getMaxMinReport
alapértelmezett összetevőben definiált parancsot:
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")
Az alábbi kódrészlet bemutatja, hogyan hívhatja meg a getMaxMinReport
parancsot egy összetevőn. A parancs a termosztát1 összetevőben van definiálva:
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")
Az IoT Plug and Play-eszközök elküldik a DTDL-modellben meghatározott telemetriát az IoT Hubnak. Az IoT Hub alapértelmezés szerint átirányítja a telemetriát egy Event Hubs-végpontra, ahol felhasználhatja. További információ: Az IoT Hub üzenet-útválasztásának használata az eszközről a felhőbe irányuló üzenetek különböző végpontokra való küldéséhez.
Az alábbi kódrészlet bemutatja, hogyan olvashatja be a telemetriát az alapértelmezett Event Hubs-végpontról. Az ebben a kódrészletben található kód az IoT Hub rövid útmutatójából származik, amely telemetriát küld egy eszközről egy IoT Hubra, és egy háttéralkalmazással olvassa el:
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()
Az előző kód alábbi kimenete a nem komponensű Termosztát IoT Plug and Play eszköz által küldött hőmérséklet-telemetriát mutatja, amely csak az alapértelmezett összetevővel rendelkezik. A dt-dataschema
rendszertulajdonság a modellazonosítót jeleníti meg:
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}
Az előző kód alábbi kimenete a többkomponensű TemperatureController IoT Plug and Play eszköz által küldött hőmérséklet-telemetriát mutatja. A dt-subject
rendszertulajdonság a telemetriát küldő összetevő nevét jeleníti meg. Ebben a példában a két összetevő a thermostat1
DTDL-modellben definiált és thermostat2
definiált. A dt-dataschema
rendszertulajdonság a modellazonosítót jeleníti meg:
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}
Az IoT Hub konfigurálható úgy, hogy ikereszköz-változási értesítéseket hozzon létre, hogy egy támogatott végpontra irányítson. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző Python-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub ikereszköz-változási értesítéseket hoz létre egy nem összetevőből álló termosztát-eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
Az előző Python-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub ikereszköz-változási értesítéseket hoz létre egy összetevőt tartalmazó eszközhöz. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
Az IoT Hub konfigurálható úgy, hogy digitális ikerpéldány-változási értesítéseket hozzon létre egy támogatott végpontra való átirányításhoz. További információ: Eszközről felhőbe irányuló üzenetek küldése az IoT Hub üzenettovábbításával különböző végpontokra > , nem telemetriai eseményekre.
Az előző Python-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre egy nem összetevő alapú termosztát-eszközhöz. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
Az előző Python-kódrészletben látható kód a következő kimenetet hozza létre, amikor az IoT Hub digitális ikerpéldány-változási értesítéseket hoz létre egy összetevőt tartalmazó eszközhöz. Ez a példa azt a kimenetet mutatja be, amikor egy termosztát-összetevővel rendelkező hőmérséklet-érzékelő eszköz értesítéseket hoz létre. Az alkalmazás tulajdonságai iothub-message-schema
és opType
a változásértesítés típusával kapcsolatos információk:
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}
Most, hogy megismerte az eszközmodellezést, íme néhány további forrás: