你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。
教程：创建客户端应用程序并将其连接到 Azure IoT Central 应用程序
重要
本文包括使用共享访问签名（也称为对称密钥身份验证）连接设备的步骤。 此身份验证方法便于测试和评估，但使用 X.509 证书对设备进行身份验证是一种更安全的方法。 若要了解详细信息，请参阅“安全最佳做法 > 连接安全性”。
本教程介绍如何将客户端应用程序连接到 Azure IoT Central 应用程序。 该应用程序模拟恒温控制设备的行为。 当应用程序连接到 IoT Central 时，它将发送恒温控制设备模型的模型 ID。 IoT Central 使用模型 ID 检索设备模型，并创建设备模板。 此外，你将向该设备模板中添加视图，使操作员能够与设备进行交互。
在本教程中，你将了解如何执行以下操作：
- 创建并运行设备代码，并查看它是否可连接到 IoT Central 应用程序。
- 查看从设备发送的模拟遥测数据。
- 将自定义视图添加到设备模板。
- 发布设备模板。
- 使用视图管理设备属性。
- 调用命令来控制设备。
先决条件
完成本教程中的步骤需要具备以下各项：
一个有效的 Azure 订阅。 如果没有 Azure 订阅，请在开始之前创建一个免费帐户。
根据自定义应用程序模板创建的 IoT Central 应用程序。 若要了解详细信息，请参阅创建 IoT Central 应用程序和关于你的应用程序。
可以在 Linux 或 Windows 上运行本教程。 本教程中的 shell 命令遵循适用于路径分隔符“/”的 Linux 约定，如果你是在 Windows 上操作，请务必将这些分隔符替换为“\”。
先决条件根据操作系统而异：
Linux
本教程假设你使用 Ubuntu Linux。 本教程中的步骤已使用 Ubuntu 18.04 进行了测试。
若要在 Linux 上完成本教程，需在本地 Linux 环境上安装以下软件：
使用 命令安装“GCC”、“Git”、“cmake”和所有必要的依赖项：
sudo apt-get update
sudo apt-get install -y git cmake build-essential curl libcurl4-openssl-dev libssl-dev uuid-dev
验证 cmake 的版本是否高于 2.8.12 以及 GCC 的版本是否高于 4.4.7。
cmake --version
gcc --version
Windows
若要在 Windows 上完成本教程，需在本地 Windows 环境上安装以下软件：
- Visual Studio（Community、Professional 或 Enterprise 版）- 安装 Visual Studio 时，请确保包括“使用 C++ 的桌面开发”工作负荷。
- Git。
- CMake。
下载代码
在本教程中，你将准备一个用于克隆和生成 Azure IoT 中心设备 C SDK 的开发环境。
在所选目录中打开命令提示符。 执行以下命令将 Azure IoT C SDK 和库 GitHub 存储库克隆到此位置：
git clone https://github.com/Azure/azure-iot-sdk-c.git
cd azure-iot-sdk-c
git submodule update --init
此操作需要几分钟才能完成。
查看代码
在先前下载的适用于 C 的 Microsoft Azure IoT SDK 副本中，使用文本编辑器打开 azure-iot-sdk-c/iothub_client/samples/pnp/pnp_temperature_controller/pnp_temperature_controller.c 和 azure-iot-sdk-c/iothub_client/samples/pnp/pnp_temperature_controller/pnp_thermostat_component.c。
此示例实现多组件温度控制器数字孪生体定义语言模型。
当你运行连接到 IoT Central 的示例时，它将使用设备预配服务 (DPS) 来注册设备并生成连接字符串。 该示例从命令行环境中检索其所需的 DPS 连接信息。
在 pnp_temperature_controller.c 中， 函数首先将 CreateDeviceClientAndAllocateComponents 调用至：
- 设置
dtmi:com:example:Thermostat;1模型 ID。 IoT Central 使用模型 ID 识别或生成此设备的设备模板。 若要了解详细信息，请参阅将设备分配到设备模板。 - 使用 DPS 预配和注册设备。
- 创建一个设备客户端句柄，并连接到你的 IoT Central 应用程序。
- 为温度控制器组件中的命令创建处理程序。
- 为温度控制器组件中的属性更新创建处理程序。
- 创建两个恒温器组件。
接着，main 函数会：
- 报告所有组件的初始属性值。
- 启动循环，从所有组件发送遥测数据。
然后，main 函数将启动一个线程来定期发送遥测数据。
int main(void)
{
IOTHUB_DEVICE_CLIENT_LL_HANDLE deviceClient = NULL;
g_pnpDeviceConfiguration.modelId = g_temperatureControllerModelId;
g_pnpDeviceConfiguration.enableTracing = g_hubClientTraceEnabled;
// First determine the IoT Hub / credentials / device to use.
if (GetConnectionSettingsFromEnvironment(&g_pnpDeviceConfiguration) == false)
{
LogError("Cannot read required environment variable(s)");
}
// Creates the thermostat subcomponents defined by this model. Since everything
// is simulated, this setup stage just creates simulated objects in memory.
else if (AllocateThermostatComponents() == false)
{
LogError("Failure allocating thermostat components");
}
// Create a handle to device client handle. Note that this call may block
// for extended periods of time when using DPS.
else if ((deviceClient = CreateAndConfigureDeviceClientHandleForPnP()) == NULL)
{
LogError("Failure creating Iot Hub device client");
PnP_ThermostatComponent_Destroy(g_thermostatHandle1);
PnP_ThermostatComponent_Destroy(g_thermostatHandle2);
}
else
{
LogInfo("Successfully created device client. Hit Control-C to exit program\n");
int numberOfIterations = 0;
// During startup, send what DTDLv2 calls "read-only properties" to indicate initial device state.
PnP_TempControlComponent_ReportSerialNumber_Property(deviceClient);
PnP_DeviceInfoComponent_Report_All_Properties(g_deviceInfoComponentName, deviceClient);
PnP_TempControlComponent_Report_MaxTempSinceLastReboot_Property(g_thermostatHandle1, deviceClient);
PnP_TempControlComponent_Report_MaxTempSinceLastReboot_Property(g_thermostatHandle2, deviceClient);
while (true)
{
// Wake up periodically to poll. Even if we do not plan on sending telemetry, we still need to poll periodically in order to process
// incoming requests from the server and to do connection keep alives.
if ((numberOfIterations % g_sendTelemetryPollInterval) == 0)
{
PnP_TempControlComponent_SendWorkingSet(deviceClient);
PnP_ThermostatComponent_SendCurrentTemperature(g_thermostatHandle1, deviceClient);
PnP_ThermostatComponent_SendCurrentTemperature(g_thermostatHandle2, deviceClient);
}
IoTHubDeviceClient_LL_DoWork(deviceClient);
ThreadAPI_Sleep(g_sleepBetweenPollsMs);
numberOfIterations++;
}
// The remainder of the code is used for cleaning up our allocated resources. It won't be executed in this
// sample (because the loop above is infinite and is only broken out of by Control-C of the program), but
// it is included for reference.
// Free the memory allocated to track simulated thermostat.
PnP_ThermostatComponent_Destroy(g_thermostatHandle1);
PnP_ThermostatComponent_Destroy(g_thermostatHandle2);
// Clean up the IoT Hub SDK handle.
IoTHubDeviceClient_LL_Destroy(deviceClient);
// Free all IoT Hub subsystem.
IoTHub_Deinit();
}
return 0;
}
在 pnp_thermostat_component.c 中，PnP_ThermostatComponent_SendCurrentTemperature 函数显示设备如何将温度遥测数据从组件发送到 IoT Central：
void PnP_ThermostatComponent_SendCurrentTemperature(PNP_THERMOSTAT_COMPONENT_HANDLE pnpThermostatComponentHandle, IOTHUB_DEVICE_CLIENT_LL_HANDLE deviceClient)
{
PNP_THERMOSTAT_COMPONENT* pnpThermostatComponent = (PNP_THERMOSTAT_COMPONENT*)pnpThermostatComponentHandle;
IOTHUB_MESSAGE_HANDLE messageHandle = NULL;
IOTHUB_MESSAGE_RESULT messageResult;
IOTHUB_CLIENT_RESULT iothubClientResult;
char temperatureStringBuffer[CURRENT_TEMPERATURE_BUFFER_SIZE];
// Create the telemetry message body to send.
if (snprintf(temperatureStringBuffer, sizeof(temperatureStringBuffer), g_temperatureTelemetryBodyFormat, pnpThermostatComponent->currentTemperature) < 0)
{
LogError("snprintf of current temperature telemetry failed");
}
// Create the message handle and specify its metadata.
else if ((messageHandle = IoTHubMessage_CreateFromString(temperatureStringBuffer)) == NULL)
{
LogError("IoTHubMessage_PnP_CreateFromString failed");
}
else if ((messageResult = IoTHubMessage_SetContentTypeSystemProperty(messageHandle, g_jsonContentType)) != IOTHUB_MESSAGE_OK)
{
LogError("IoTHubMessage_SetContentTypeSystemProperty failed, error=%d", messageResult);
}
else if ((messageResult = IoTHubMessage_SetContentEncodingSystemProperty(messageHandle, g_utf8EncodingType)) != IOTHUB_MESSAGE_OK)
{
LogError("IoTHubMessage_SetContentEncodingSystemProperty failed, error=%d", messageResult);
}
else if ((messageResult = IoTHubMessage_SetComponentName(messageHandle, pnpThermostatComponent->componentName)) != IOTHUB_MESSAGE_OK)
{
LogError("IoTHubMessage_SetContentEncodingSystemProperty failed, error=%d", messageResult);
}
// Send the telemetry message.
else if ((iothubClientResult = IoTHubDeviceClient_LL_SendTelemetryAsync(deviceClient, messageHandle, NULL, NULL)) != IOTHUB_CLIENT_OK)
{
LogError("Unable to send telemetry message, error=%d", iothubClientResult);
}
IoTHubMessage_Destroy(messageHandle);
}
在 pnp_thermostat_component.c 中，PnP_TempControlComponent_Report_MaxTempSinceLastReboot_Property 函数将 maxTempSinceLastReboot 属性更新从组件发送到 IoT Central：
void PnP_TempControlComponent_Report_MaxTempSinceLastReboot_Property(PNP_THERMOSTAT_COMPONENT_HANDLE pnpThermostatComponentHandle, IOTHUB_DEVICE_CLIENT_LL_HANDLE deviceClient)
{
PNP_THERMOSTAT_COMPONENT* pnpThermostatComponent = (PNP_THERMOSTAT_COMPONENT*)pnpThermostatComponentHandle;
char maximumTemperatureAsString[MAX_TEMPERATURE_SINCE_REBOOT_BUFFER_SIZE];
IOTHUB_CLIENT_RESULT iothubClientResult;
if (snprintf(maximumTemperatureAsString, sizeof(maximumTemperatureAsString), g_maxTempSinceLastRebootPropertyFormat, pnpThermostatComponent->maxTemperature) < 0)
{
LogError("Unable to create max temp since last reboot string for reporting result");
}
else
{
IOTHUB_CLIENT_PROPERTY_REPORTED maxTempProperty;
maxTempProperty.structVersion = IOTHUB_CLIENT_PROPERTY_REPORTED_STRUCT_VERSION_1;
maxTempProperty.name = g_maxTempSinceLastRebootPropertyName;
maxTempProperty.value = maximumTemperatureAsString;
unsigned char* propertySerialized = NULL;
size_t propertySerializedLength;
// The first step of reporting properties is to serialize IOTHUB_CLIENT_PROPERTY_WRITABLE_RESPONSE into JSON for sending.
if ((iothubClientResult = IoTHubClient_Properties_Serializer_CreateReported(&maxTempProperty, 1, pnpThermostatComponent->componentName, &propertySerialized, &propertySerializedLength)) != IOTHUB_CLIENT_OK)
{
LogError("Unable to serialize reported state, error=%d", iothubClientResult);
}
// The output of IoTHubClient_Properties_Serializer_CreateReported is sent to IoTHubDeviceClient_LL_SendPropertiesAsync to perform network I/O.
else if ((iothubClientResult = IoTHubDeviceClient_LL_SendPropertiesAsync(deviceClient, propertySerialized, propertySerializedLength, NULL, NULL)) != IOTHUB_CLIENT_OK)
{
LogError("Unable to send reported state, error=%d", iothubClientResult);
}
else
{
LogInfo("Sending %s property to IoTHub for component %s", g_maxTempSinceLastRebootPropertyName, pnpThermostatComponent->componentName);
}
IoTHubClient_Properties_Serializer_Destroy(propertySerialized);
}
}
在 pnp_thermostat_component.c 中，PnP_ThermostatComponent_ProcessPropertyUpdate 函数处理来自 IoT Central 的可写属性更新：
void PnP_ThermostatComponent_ProcessPropertyUpdate(PNP_THERMOSTAT_COMPONENT_HANDLE pnpThermostatComponentHandle, IOTHUB_DEVICE_CLIENT_LL_HANDLE deviceClient, const char* propertyName, const char* propertyValue, int version)
{
PNP_THERMOSTAT_COMPONENT* pnpThermostatComponent = (PNP_THERMOSTAT_COMPONENT*)pnpThermostatComponentHandle;
if (strcmp(propertyName, g_targetTemperaturePropertyName) != 0)
{
LogError("Property %s was requested to be changed but is not part of the thermostat interface definition", propertyName);
}
else
{
char* next;
double targetTemperature = strtod(propertyValue, &next);
if ((propertyValue == next) || (targetTemperature == HUGE_VAL) || (targetTemperature == (-1*HUGE_VAL)))
{
LogError("Property %s is not a valid number", propertyValue);
SendTargetTemperatureResponse(pnpThermostatComponent, deviceClient, propertyValue, PNP_STATUS_BAD_FORMAT, version, g_temperaturePropertyResponseDescriptionNotInt);
}
else
{
LogInfo("Received targetTemperature %f for component %s", targetTemperature, pnpThermostatComponent->componentName);
bool maxTempUpdated = false;
UpdateTemperatureAndStatistics(pnpThermostatComponent, targetTemperature, &maxTempUpdated);
// The device needs to let the service know that it has received the targetTemperature desired property.
SendTargetTemperatureResponse(pnpThermostatComponent, deviceClient, propertyValue, PNP_STATUS_SUCCESS, version, NULL);
if (maxTempUpdated)
{
// If the maximum temperature has been updated, we also report this as a property.
PnP_TempControlComponent_Report_MaxTempSinceLastReboot_Property(pnpThermostatComponent, deviceClient);
}
}
}
}
在 pnp_thermostat_component.c 中，PnP_ThermostatComponent_ProcessCommand 函数处理从 IoT Central 调用的命令：
void PnP_ThermostatComponent_ProcessCommand(PNP_THERMOSTAT_COMPONENT_HANDLE pnpThermostatComponentHandle, const char *pnpCommandName, JSON_Value* commandJsonValue, IOTHUB_CLIENT_COMMAND_RESPONSE* commandResponse)
{
PNP_THERMOSTAT_COMPONENT* pnpThermostatComponent = (PNP_THERMOSTAT_COMPONENT*)pnpThermostatComponentHandle;
const char* sinceStr;
if (strcmp(pnpCommandName, g_getMaxMinReportCommandName) != 0)
{
LogError("Command %s is not supported on thermostat component", pnpCommandName);
commandResponse->statusCode = PNP_STATUS_NOT_FOUND;
}
// See caveats section in ../readme.md; we don't actually respect this sinceStr to keep the sample simple,
// but want to demonstrate how to parse out in any case.
else if ((sinceStr = json_value_get_string(commandJsonValue)) == NULL)
{
LogError("Cannot retrieve JSON string for command");
commandResponse->statusCode = PNP_STATUS_BAD_FORMAT;
}
else if (BuildMaxMinCommandResponse(pnpThermostatComponent, commandResponse) == false)
{
LogError("Unable to build response for component %s", pnpThermostatComponent->componentName);
commandResponse->statusCode = PNP_STATUS_INTERNAL_ERROR;
}
else
{
LogInfo("Returning success from command request for component %s", pnpThermostatComponent->componentName);
commandResponse->statusCode = PNP_STATUS_SUCCESS;
}
}
生成代码
使用设备 SDK 生成包含的示例代码：
在设备 SDK 根文件夹中创建一个 cmake 子目录，并导航到该文件夹：
cd azure-iot-sdk-c mkdir cmake cd cmake运行以下命令以生成 SDK 和示例：
cmake -Duse_prov_client=ON -Dhsm_type_symm_key=ON -Drun_e2e_tests=OFF .. cmake --build .
获取连接信息
在本教程的后面部分中运行示例设备应用程序时，需要以下配置值：
- ID 范围：在 IoT Central 应用程序中，导航到“权限”“设备连接组”。 记下“ID 范围”值。
- 组主键：在 IoT Central 应用程序中，导航到“权限”“设备连接组”>“SAS-IoT-Devices”。 记下共享访问签名主键值。
使用 Azure Cloud Shell 从检索的组主键生成设备密钥：
az extension add --name azure-iot
az iot central device compute-device-key --device-id sample-device-01 --pk <the group primary key value>
记下生成的设备密钥，本教程的后面部分中将用到它。
注意
若要运行此示例，无需在 IoT Central 应用程序中提前注册设备。 此示例使用 IoT Central 功能在首次连接时自动注册设备。
运行代码
若要运行示例应用程序，请打开一个命令行环境，然后导航到 azure-iot-sdk-c\cmake 文件夹。
设置环境变量以配置示例。 以下代码片段演示如何在 Windows 命令提示符下设置环境变量。 如果使用 bash shell，请将 命令替换为 export 命令：
set IOTHUB_DEVICE_SECURITY_TYPE=DPS
set IOTHUB_DEVICE_DPS_ID_SCOPE=<The ID scope you made a note of previously>
set IOTHUB_DEVICE_DPS_DEVICE_ID=sample-device-01
set IOTHUB_DEVICE_DPS_DEVICE_KEY=<The generated device key you made a note of previously>
set IOTHUB_DEVICE_DPS_ENDPOINT=global.azure-devices-provisioning.net
若要运行该示例：
# Bash
cd iothub_client/samples/pnp/pnp_temperature_controller/
./pnp_temperature_controller
REM Windows
cd iothub_client\samples\pnp\pnp_temperature_controller\Debug
.\pnp_temperature_controller.exe
以下输出显示设备注册并连接到 IoT Central。 示例开始发送遥测：
Info: Initiating DPS client to retrieve IoT Hub connection information
-> 09:43:27 CONNECT | VER: 4 | KEEPALIVE: 0 | FLAGS: 194 | USERNAME: 0ne0026656D/registrations/sample-device-01/api-version=2019-03-31&ClientVersion=1.6.0 | PWD: XXXX | CLEAN: 1
<- 09:43:28 CONNACK | SESSION_PRESENT: false | RETURN_CODE: 0x0
-> 09:43:29 SUBSCRIBE | PACKET_ID: 1 | TOPIC_NAME: $dps/registrations/res/# | QOS: 1
<- 09:43:30 SUBACK | PACKET_ID: 1 | RETURN_CODE: 1
-> 09:43:30 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_MOST_ONCE | TOPIC_NAME: $dps/registrations/PUT/iotdps-register/?$rid=1 | PAYLOAD_LEN: 102
<- 09:43:31 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_LEAST_ONCE | TOPIC_NAME: $dps/registrations/res/202/?$rid=1&retry-after=3 | PACKET_ID: 2 | PAYLOAD_LEN: 94
-> 09:43:31 PUBACK | PACKET_ID: 2
-> 09:43:33 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_MOST_ONCE | TOPIC_NAME: $dps/registrations/GET/iotdps-get-operationstatus/?$rid=2&operationId=4.2f792ade0a5c3e68.baf0e879-d88a-4153-afef-71aff51fd847 | PAYLOAD_LEN: 102
<- 09:43:34 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_LEAST_ONCE | TOPIC_NAME: $dps/registrations/res/202/?$rid=2&retry-after=3 | PACKET_ID: 2 | PAYLOAD_LEN: 173
-> 09:43:34 PUBACK | PACKET_ID: 2
-> 09:43:36 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_MOST_ONCE | TOPIC_NAME: $dps/registrations/GET/iotdps-get-operationstatus/?$rid=3&operationId=4.2f792ade0a5c3e68.baf0e879-d88a-4153-afef-71aff51fd847 | PAYLOAD_LEN: 102
<- 09:43:37 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_LEAST_ONCE | TOPIC_NAME: $dps/registrations/res/200/?$rid=3 | PACKET_ID: 2 | PAYLOAD_LEN: 478
-> 09:43:37 PUBACK | PACKET_ID: 2
Info: Provisioning callback indicates success. iothubUri=iotc-60a....azure-devices.net, deviceId=sample-device-01
-> 09:43:37 DISCONNECT
Info: DPS successfully registered. Continuing on to creation of IoTHub device client handle.
Info: Successfully created device client. Hit Control-C to exit program
Info: Sending serialNumber property to IoTHub
Info: Sending device information property to IoTHub. propertyName=swVersion, propertyValue="1.0.0.0"
Info: Sending device information property to IoTHub. propertyName=manufacturer, propertyValue="Sample-Manufacturer"
Info: Sending device information property to IoTHub. propertyName=model, propertyValue="sample-Model-123"
Info: Sending device information property to IoTHub. propertyName=osName, propertyValue="sample-OperatingSystem-name"
Info: Sending device information property to IoTHub. propertyName=processorArchitecture, propertyValue="Contoso-Arch-64bit"
Info: Sending device information property to IoTHub. propertyName=processorManufacturer, propertyValue="Processor Manufacturer(TM)"
Info: Sending device information property to IoTHub. propertyName=totalStorage, propertyValue=10000
Info: Sending device information property to IoTHub. propertyName=totalMemory, propertyValue=200
Info: Sending maximumTemperatureSinceLastReboot property to IoTHub for component=thermostat1
Info: Sending maximumTemperatureSinceLastReboot property to IoTHub for component=thermostat2
-> 09:43:44 CONNECT | VER: 4 | KEEPALIVE: 240 | FLAGS: 192 | USERNAME: iotc-60a576a2-eec7-48e2-9306-9e7089a79995.azure-devices.net/sample-device-01/?api-version=2020-09-30&DeviceClientType=iothubclient%2f1.6.0%20(native%3b%20Linux%3b%20x86_64)&model-id=dtmi%3acom%3aexample%3aTemperatureController%3b1 | PWD: XXXX | CLEAN: 0
<- 09:43:44 CONNACK | SESSION_PRESENT: false | RETURN_CODE: 0x0
-> 09:43:44 SUBSCRIBE | PACKET_ID: 2 | TOPIC_NAME: $iothub/twin/res/# | QOS: 0 | TOPIC_NAME: $iothub/methods/POST/# | QOS: 0
-> 09:43:44 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_LEAST_ONCE | TOPIC_NAME: devices/sample-device-01/messages/events/ | PACKET_ID: 3 | PAYLOAD_LEN: 19
-> 09:43:44 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_LEAST_ONCE | TOPIC_NAME: devices/sample-device-01/messages/events/%24.sub=thermostat1 | PACKET_ID: 4 | PAYLOAD_LEN: 21
-> 09:43:44 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_LEAST_ONCE | TOPIC_NAME: devices/sample-device-01/messages/events/%24.sub=thermostat2 | PACKET_ID: 5 | PAYLOAD_LEN: 21
Azure IoT Central 应用程序中的操作员可以：
在“概述”页上查看两个恒温组件发送的遥测数据：
在“关于”页上查看设备属性。 此页显示设备信息组件和两个恒温器组件的属性：
自定义设备模板
作为解决方案开发人员，你可以对 IoT Central 在温度控制器设备连接时自动创建的设备模板进行自定义。
添加云属性以存储与设备关联的客户名称：
在 IoT Central 应用程序中，导航到“设备模板”页面上的“温度控制器”设备模板 。
在“温度控制器”模型中，选择“+添加功能”。
输入“客户名称”作为“显示名称”，选择“云属性”作为“功能类型”，然后扩展条目并选择“字符串”作为“架构”。 再选择“保存”。
若要自定义“获取最高-最低温度报告”命令在 IoT Central 应用程序中的显示方式，请按照以下说明操作：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“getMaxMinReport (thermostat1)”，请将“获取最高-最低温度报告”替换为“获取 thermostat1 状态报告”。
对于“getMaxMinReport (thermostat2)”，请将“获取最高-最低温度报告”替换为“获取 thermostat2 状态报告”。
选择“保存”。
若要自定义“目标温度”可写属性在 IoT Central 应用程序中的显示方式：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“targetTemperature (thermostat1)”，请将“目标温度”替换为“目标温度 (1)”。
对于“targetTemperature (thermostat2)”，请将“目标温度”替换为“目标温度 (2)”。
选择“保存”。
“温度控制器”模型中的恒温器组件包含“目标温度”可写属性，设备模板包含“客户名称”云属性。 操作员可以使用“创建视图”来编辑以下属性：
选择“视图”，然后选择“编辑设备和云数据”磁贴。
输入“属性”作为窗体名称。
选择“目标温度(1)”、“目标温度(2)”和“客户名称”属性。 然后选择“添加部分”。
保存所做更改。
发布设备模板
必须先发布设备模板，操作员才能查看和使用你进行的自定义。
从“恒温器”设备模板中，选择“发布”。 在“将此设备模板发布到应用程序”面板中，选择“发布”。
操作员现在可以使用“属性”视图来更新属性值，并在设备命令页上调用“获取恒温器 1 状态报告”和“获取恒温器 2 状态报告”的命令：
更新“属性”页上的可写属性值：
从“命令”页中调用命令。 如果运行状态报告命令，请在运行该命令之前为参数“自”选择一个日期和时间：
可以看到设备如何对命令和属性更新做出响应：
<- 09:49:03 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_MOST_ONCE | TOPIC_NAME: $iothub/methods/POST/thermostat1*getMaxMinReport/?$rid=1 | PAYLOAD_LEN: 26
Info: Received PnP command for component=thermostat1, command=getMaxMinReport
Info: Returning success from command request for component=thermostat1
-> 09:49:03 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_MOST_ONCE | TOPIC_NAME: $iothub/methods/res/200/?$rid=1 | PAYLOAD_LEN: 117
...
<- 09:50:04 PUBLISH | IS_DUP: false | RETAIN: 0 | QOS: DELIVER_AT_MOST_ONCE | TOPIC_NAME: $iothub/twin/PATCH/properties/desired/?$version=2 | PAYLOAD_LEN: 63
Info: Received targetTemperature=67.000000 for component=thermostat2
Info: Sending acknowledgement of property to IoTHub for component=thermostat2
先决条件
若要完成本文中的步骤，需要准备好以下资源：
一个有效的 Azure 订阅。 如果没有 Azure 订阅，请在开始之前创建一个免费帐户。
根据自定义应用程序模板创建的 IoT Central 应用程序。 若要了解详细信息，请参阅创建 IoT Central 应用程序和关于你的应用程序。
安装了 Visual Studio（Community、Professional 或 Enterprise 版）的开发计算机。
适用于 C# (.NET) 的 Microsoft Azure IoT SDK GitHub 存储库（包含示例代码）的本地副本。 使用此链接下载存储库副本：下载 ZIP。 然后将该文件解压缩到本地计算机上的适当位置。
查看代码
在之前下载的适用于 C# 的 Microsoft Azure IoT SDK 存储库的副本中，使用 Visual Studio 打开“azure-iot-sdk-csharp-main\azureiot.sln”解决方案文件。 在“解决方案资源管理器”中，展开“PnpDeviceSamples”“TemperatureController”文件夹，然后打开“Program.cs”和“TemperatureControllerSample.cs”文件来查看此示例代码。
此示例实现多组件温度控制器数字孪生体定义语言模型。
当你运行连接到 IoT Central 的示例时，它将使用设备预配服务 (DPS) 来注册设备并生成连接字符串。 该示例从环境中检索其所需的 DPS 连接信息。
在 Program.cs 中， 方法调用 SetupDeviceClientAsync，以实现以下操作：
- 当为设备预配 DPS 时，请使用模型 ID
dtmi:com:example:TemperatureController;2。 IoT Central 使用模型 ID 识别或生成此设备的设备模板。 若要了解详细信息，请参阅将设备分配到设备模板。 - 创建 DeviceClient 实例以连接到 IoT Central。
private static async Task<DeviceClient> SetupDeviceClientAsync(Parameters parameters, CancellationToken cancellationToken)
{
DeviceClient deviceClient;
switch (parameters.DeviceSecurityType.ToLowerInvariant())
{
case "dps":
DeviceRegistrationResult dpsRegistrationResult = await ProvisionDeviceAsync(parameters, cancellationToken);
var authMethod = new DeviceAuthenticationWithRegistrySymmetricKey(dpsRegistrationResult.DeviceId, parameters.DeviceSymmetricKey);
deviceClient = InitializeDeviceClient(dpsRegistrationResult.AssignedHub, authMethod);
break;
case "connectionstring":
// ...
default:
// ...
}
return deviceClient;
}
然后，main 方法创建 TemperatureControllerSample 实例，并调用 方法来处理与 IoT Central 的交互。
在 TemperatureControllerSample.cs 中， 方法：
- 为默认组件上的“重启”命令设置处理程序。
- 为两个恒温器组件上的 getMaxMinReport 命令设置处理程序。
- 设置处理程序，以便在两个恒温器组件上接收目标温度属性更新。
- 发送初始设备信息属性更新。
- 定期从两个恒温器组件发送温度遥测数据。
- 定期从默认组件发送工作集遥测数据。
- 每当这两个恒温器组件达到新的最高温度，系统就会发送自上次重启以来的最高温度。
public async Task PerformOperationsAsync(CancellationToken cancellationToken)
{
await _deviceClient.SetMethodHandlerAsync("reboot", HandleRebootCommandAsync, _deviceClient, cancellationToken);
// For a component-level command, the command name is in the format "<component-name>*<command-name>".
await _deviceClient.SetMethodHandlerAsync("thermostat1*getMaxMinReport", HandleMaxMinReportCommand, Thermostat1, cancellationToken);
await _deviceClient.SetMethodHandlerAsync("thermostat2*getMaxMinReport", HandleMaxMinReportCommand, Thermostat2, cancellationToken);
await _deviceClient.SetDesiredPropertyUpdateCallbackAsync(SetDesiredPropertyUpdateCallback, null, cancellationToken);
_desiredPropertyUpdateCallbacks.Add(Thermostat1, TargetTemperatureUpdateCallbackAsync);
_desiredPropertyUpdateCallbacks.Add(Thermostat2, TargetTemperatureUpdateCallbackAsync);
await UpdateDeviceInformationAsync(cancellationToken);
await SendDeviceSerialNumberAsync(cancellationToken);
bool temperatureReset = true;
_maxTemp[Thermostat1] = 0d;
_maxTemp[Thermostat2] = 0d;
while (!cancellationToken.IsCancellationRequested)
{
if (temperatureReset)
{
// Generate a random value between 5.0°C and 45.0°C for the current temperature reading for each "Thermostat" component.
_temperature[Thermostat1] = Math.Round(s_random.NextDouble() * 40.0 + 5.0, 1);
_temperature[Thermostat2] = Math.Round(s_random.NextDouble() * 40.0 + 5.0, 1);
}
await SendTemperatureAsync(Thermostat1, cancellationToken);
await SendTemperatureAsync(Thermostat2, cancellationToken);
await SendDeviceMemoryAsync(cancellationToken);
temperatureReset = _temperature[Thermostat1] == 0 && _temperature[Thermostat2] == 0;
await Task.Delay(5 * 1000);
}
}
SendTemperatureAsync 方法显示设备如何将温度遥测数据从组件发送到 IoT Central。 SendTemperatureTelemetryAsync 方法使用 PnpConvention 类生成消息：
private async Task SendTemperatureAsync(string componentName, CancellationToken cancellationToken)
{
await SendTemperatureTelemetryAsync(componentName, cancellationToken);
double maxTemp = _temperatureReadingsDateTimeOffset[componentName].Values.Max<double>();
if (maxTemp > _maxTemp[componentName])
{
_maxTemp[componentName] = maxTemp;
await UpdateMaxTemperatureSinceLastRebootAsync(componentName, cancellationToken);
}
}
private async Task SendTemperatureTelemetryAsync(string componentName, CancellationToken cancellationToken)
{
const string telemetryName = "temperature";
double currentTemperature = _temperature[componentName];
using Message msg = PnpConvention.CreateMessage(telemetryName, currentTemperature, componentName);
await _deviceClient.SendEventAsync(msg, cancellationToken);
if (_temperatureReadingsDateTimeOffset.ContainsKey(componentName))
{
_temperatureReadingsDateTimeOffset[componentName].TryAdd(DateTimeOffset.UtcNow, currentTemperature);
}
else
{
_temperatureReadingsDateTimeOffset.TryAdd(
componentName,
new Dictionary<DateTimeOffset, double>
{
{ DateTimeOffset.UtcNow, currentTemperature },
});
}
}
UpdateMaxTemperatureSinceLastRebootAsync 方法将 maxTempSinceLastReboot 属性更新发送到 IoT Central。 此方法使用 PnpConvention 类创建补丁：
private async Task UpdateMaxTemperatureSinceLastRebootAsync(string componentName, CancellationToken cancellationToken)
{
const string propertyName = "maxTempSinceLastReboot";
double maxTemp = _maxTemp[componentName];
TwinCollection reportedProperties = PnpConvention.CreateComponentPropertyPatch(componentName, propertyName, maxTemp);
await _deviceClient.UpdateReportedPropertiesAsync(reportedProperties, cancellationToken);
}
TargetTemperatureUpdateCallbackAsync 方法处理来自 IoT Central 的可写目标温度属性更新。 此方法使用 PnpConvention 类读取属性更新消息并构造响应：
private async Task TargetTemperatureUpdateCallbackAsync(TwinCollection desiredProperties, object userContext)
{
const string propertyName = "targetTemperature";
string componentName = (string)userContext;
bool targetTempUpdateReceived = PnpConvention.TryGetPropertyFromTwin(
desiredProperties,
propertyName,
out double targetTemperature,
componentName);
if (!targetTempUpdateReceived)
{
return;
}
TwinCollection pendingReportedProperty = PnpConvention.CreateComponentWritablePropertyResponse(
componentName,
propertyName,
targetTemperature,
(int)StatusCode.InProgress,
desiredProperties.Version);
await _deviceClient.UpdateReportedPropertiesAsync(pendingReportedProperty);
// Update Temperature in 2 steps
double step = (targetTemperature - _temperature[componentName]) / 2d;
for (int i = 1; i <= 2; i++)
{
_temperature[componentName] = Math.Round(_temperature[componentName] + step, 1);
await Task.Delay(6 * 1000);
}
TwinCollection completedReportedProperty = PnpConvention.CreateComponentWritablePropertyResponse(
componentName,
propertyName,
_temperature[componentName],
(int)StatusCode.Completed,
desiredProperties.Version,
"Successfully updated target temperature");
await _deviceClient.UpdateReportedPropertiesAsync(completedReportedProperty);
}
HandleMaxMinReportCommand 方法处理从 IoT Central 调用的组件的命令：
private Task<MethodResponse> HandleMaxMinReportCommand(MethodRequest request, object userContext)
{
try
{
string componentName = (string)userContext;
DateTime sinceInUtc = JsonConvert.DeserializeObject<DateTime>(request.DataAsJson);
var sinceInDateTimeOffset = new DateTimeOffset(sinceInUtc);
if (_temperatureReadingsDateTimeOffset.ContainsKey(componentName))
{
Dictionary<DateTimeOffset, double> allReadings = _temperatureReadingsDateTimeOffset[componentName];
Dictionary<DateTimeOffset, double> filteredReadings = allReadings.Where(i => i.Key > sinceInDateTimeOffset)
.ToDictionary(i => i.Key, i => i.Value);
if (filteredReadings != null && filteredReadings.Any())
{
var report = new
{
maxTemp = filteredReadings.Values.Max<double>(),
minTemp = filteredReadings.Values.Min<double>(),
avgTemp = filteredReadings.Values.Average(),
startTime = filteredReadings.Keys.Min(),
endTime = filteredReadings.Keys.Max(),
};
byte[] responsePayload = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(report));
return Task.FromResult(new MethodResponse(responsePayload, (int)StatusCode.Completed));
}
return Task.FromResult(new MethodResponse((int)StatusCode.NotFound));
}
return Task.FromResult(new MethodResponse((int)StatusCode.NotFound));
}
catch (JsonReaderException ex)
{
// ...
}
}
获取连接信息
在本教程的后面部分中运行示例设备应用程序时，需要以下配置值：
- ID 范围：在 IoT Central 应用程序中，导航到“权限”“设备连接组”。 记下“ID 范围”值。
- 组主键：在 IoT Central 应用程序中，导航到“权限”“设备连接组”>“SAS-IoT-Devices”。 记下共享访问签名主键值。
使用 Azure Cloud Shell 从检索的组主键生成设备密钥：
az extension add --name azure-iot
az iot central device compute-device-key --device-id sample-device-01 --pk <the group primary key value>
记下生成的设备密钥，本教程的后面部分中将用到它。
注意
若要运行此示例，无需在 IoT Central 应用程序中提前注册设备。 此示例使用 IoT Central 功能在首次连接时自动注册设备。
运行代码
备注
在运行代码之前，将 TemperatureController 设置为启动项目。
如要在 Visual Studio 中运行示例应用程序：
在“解决方案资源管理器”中，选择“PnpDeviceSamples”“TemperatureController”项目文件。
导航到“项目”“温度控制器属性”>“调试”。 然后，将以下环境变量添加到项目：
名称 值 IOTHUB_DEVICE_SECURITY_TYPE DPS IOTHUB_DEVICE_DPS_ENDPOINT global.azure-devices-provisioning.net IOTHUB_DEVICE_DPS_ID_SCOPE 之前记下的 ID 范围值。 IOTHUB_DEVICE_DPS_DEVICE_ID sample-device-01 IOTHUB_DEVICE_DPS_DEVICE_KEY 之前记下的生成的设备密钥值。
现在，可以在 Visual Studio 中运行和调试示例。
以下输出显示设备注册并连接到 IoT Central。 示例开始发送遥测：
[03/31/2021 14:43:17]info: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Press Control+C to quit the sample.
[03/31/2021 14:43:17]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Set up the device client.
[03/31/2021 14:43:18]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Initializing via DPS
[03/31/2021 14:43:27]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Set handler for 'reboot' command.
[03/31/2021 14:43:27]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Connection status change registered - status=Connected, reason=Connection_Ok.
[03/31/2021 14:43:28]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Set handler for "getMaxMinReport" command.
[03/31/2021 14:43:28]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Set handler to receive 'targetTemperature' updates.
[03/31/2021 14:43:28]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Property: Update - component = 'deviceInformation', properties update is complete.
[03/31/2021 14:43:28]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Property: Update - { "serialNumber": "SR-123456" } is complete.
[03/31/2021 14:43:29]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Telemetry: Sent - component="thermostat1", { "temperature": 34.2 } in °C.
[03/31/2021 14:43:29]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Property: Update - component="thermostat1", { "maxTempSinceLastReboot": 34.2 } in °C is complete.
[03/31/2021 14:43:29]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Telemetry: Sent - component="thermostat2", { "temperature": 25.1 } in °C.
[03/31/2021 14:43:29]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Property: Update - component="thermostat2", { "maxTempSinceLastReboot": 25.1 } in °C is complete.
[03/31/2021 14:43:29]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Telemetry: Sent - {"workingSet":31412} in KB.
Azure IoT Central 应用程序中的操作员可以：
在“概述”页上查看两个恒温组件发送的遥测数据：
在“关于”页上查看设备属性。 此页显示设备信息组件和两个恒温器组件的属性：
自定义设备模板
作为解决方案开发人员，你可以对 IoT Central 在温度控制器设备连接时自动创建的设备模板进行自定义。
添加云属性以存储与设备关联的客户名称：
在 IoT Central 应用程序中，导航到“设备模板”页面上的“温度控制器”设备模板 。
在“温度控制器”模型中，选择“+添加功能”。
输入“客户名称”作为“显示名称”，选择“云属性”作为“功能类型”，然后扩展条目并选择“字符串”作为“架构”。 再选择“保存”。
若要自定义“获取最高-最低温度报告”命令在 IoT Central 应用程序中的显示方式，请按照以下说明操作：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“getMaxMinReport (thermostat1)”，请将“获取最高-最低温度报告”替换为“获取 thermostat1 状态报告”。
对于“getMaxMinReport (thermostat2)”，请将“获取最高-最低温度报告”替换为“获取 thermostat2 状态报告”。
选择“保存”。
若要自定义“目标温度”可写属性在 IoT Central 应用程序中的显示方式：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“targetTemperature (thermostat1)”，请将“目标温度”替换为“目标温度 (1)”。
对于“targetTemperature (thermostat2)”，请将“目标温度”替换为“目标温度 (2)”。
选择“保存”。
“温度控制器”模型中的恒温器组件包含“目标温度”可写属性，设备模板包含“客户名称”云属性。 操作员可以使用“创建视图”来编辑以下属性：
选择“视图”，然后选择“编辑设备和云数据”磁贴。
输入“属性”作为窗体名称。
选择“目标温度(1)”、“目标温度(2)”和“客户名称”属性。 然后选择“添加部分”。
保存所做更改。
发布设备模板
必须先发布设备模板，操作员才能查看和使用你进行的自定义。
从“恒温器”设备模板中，选择“发布”。 在“将此设备模板发布到应用程序”面板中，选择“发布”。
操作员现在可以使用“属性”视图来更新属性值，并在设备命令页上调用“获取恒温器 1 状态报告”和“获取恒温器 2 状态报告”的命令：
更新“属性”页上的可写属性值：
从“命令”页中调用命令。 如果运行状态报告命令，请在运行该命令之前为参数“自”选择一个日期和时间：
可以看到设备如何对命令和属性更新做出响应：
[03/31/2021 14:47:00]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Command: Received - component="thermostat2", generating max, min and avg temperature report since 31/03/2021 06:00:00.
[03/31/2021 14:47:00]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Command: component="thermostat2", MaxMinReport since 31/03/2021 06:00:00: maxTemp=36.4, minTemp=36.4, avgTemp=36.4, startTime=31/03/2021 14:46:33, endTime=31/03/2021 14:46:55
...
[03/31/2021 14:46:36]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Property: Received - component="thermostat1", { "targetTemperature": 67°C }.
[03/31/2021 14:46:36]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Property: Update - component="thermostat1", {"targetTemperature": 67 } in °C is InProgress.
[03/31/2021 14:46:49]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Property: Update - component="thermostat1", {"targetTemperature": 67 } in °C is Completed
[03/31/2021 14:46:49]dbug: Microsoft.Azure.Devices.Client.Samples.TemperatureControllerSample[0]
Telemetry: Sent - component="thermostat1", { "temperature": 67 } in °C.
先决条件
若要完成本文中的步骤，需要准备好以下资源：
一个有效的 Azure 订阅。 如果没有 Azure 订阅，请在开始之前创建一个免费帐户。
根据自定义应用程序模板创建的 IoT Central 应用程序。 若要了解详细信息，请参阅创建 IoT Central 应用程序和关于你的应用程序。
具有 Java SE 开发工具包 8 或更高版本的开发计算机。 有关详细信息，请参阅安装 JDK。
适用于 Java 的 Microsoft Azure IoT SDK GitHub 存储库（包含示例代码）的本地副本。 使用此链接下载存储库副本：下载 ZIP。 然后将该文件解压缩到本地计算机上的适当位置。
查看代码
在之前下载的适用于 Java 的 Microsoft Azure IoT SDK 副本中，使用文本编辑器打开 azure-iot-sdk-java/iothub/device/iot-device-samples/pnp-device-sample/temperature-controller-device-sample/src/main/java/samples/com/microsoft/azure/sdk/iot/device/TemperatureController.java 文件。
此示例实现多组件温度控制器数字孪生体定义语言模型。
当你运行连接到 IoT Central 的示例时，它将使用设备预配服务 (DPS) 来注册设备并生成连接字符串。 该示例从命令行环境中检索其所需的 DPS 连接信息。
main 方法：
- 调用
initializeAndProvisionDevice来设置dtmi:com:example:TemperatureController;2模型 ID、使用 DPS 来预配和注册设备、创建 DeviceClient 实例以及连接到 IoT Central 应用程序。 IoT Central 使用模型 ID 识别或生成此设备的设备模板。 若要了解详细信息，请参阅将设备分配到设备模板。 - 为
getMaxMinReport和reboot命令创建命令处理程序。 - 为可写
targetTemperature属性创建属性更新处理程序。 - 为“设备信息”接口中的属性、“设备内存”和“序列号”属性发送初始值。
- 启动线程，每 5 秒从两个恒温器发送一次温度遥测数据，并更新
maxTempSinceLastReboot属性。
public static void main(String[] args) throws Exception {
// ...
switch (deviceSecurityType.toLowerCase())
{
case "dps":
{
if (validateArgsForDpsFlow())
{
initializeAndProvisionDevice();
break;
}
throw new IllegalArgumentException("Required environment variables are not set for DPS flow, please recheck your environment.");
}
case "connectionstring":
{
// ...
}
default:
{
// ...
}
}
deviceClient.subscribeToMethods(new MethodCallback(), null);
deviceClient.subscribeToDesiredPropertiesAsync(
{
(twin, context) ->
TwinCollection desiredProperties = twin.getDesiredProperties();
for (String desiredPropertyKey : desiredProperties.keySet())
{
TargetTemperatureUpdateCallback.onPropertyChanged(new Property(desiredPropertyKey, desiredProperties.get(desiredPropertyKey)), null);
}
},
null,
(exception, context) ->
{
if (exception == null)
{
log.info("Successfully subscribed to desired properties. Getting initial state");
deviceClient.getTwinAsync(
(twin, getTwinException, getTwinContext) ->
{
log.info("Initial twin state received");
log.info(twin.toString());
},
null);
}
else
{
log.info("Failed to subscribe to desired properties. Error code {}", exception.getStatusCode());
System.exit(-1);
}
},
null);
updateDeviceInformation();
sendDeviceMemory();
sendDeviceSerialNumber();
final AtomicBoolean temperatureReset = new AtomicBoolean(true);
maxTemperature.put(THERMOSTAT_1, 0.0d);
maxTemperature.put(THERMOSTAT_2, 0.0d);
new Thread(new Runnable() {
@SneakyThrows({InterruptedException.class, IOException.class})
@Override
public void run() {
while (true) {
if (temperatureReset.get()) {
// Generate a random value between 5.0°C and 45.0°C for the current temperature reading for each "Thermostat" component.
temperature.put(THERMOSTAT_1, BigDecimal.valueOf(random.nextDouble() * 40 + 5).setScale(1, RoundingMode.HALF_UP).doubleValue());
temperature.put(THERMOSTAT_2, BigDecimal.valueOf(random.nextDouble() * 40 + 5).setScale(1, RoundingMode.HALF_UP).doubleValue());
}
sendTemperatureReading(THERMOSTAT_1);
sendTemperatureReading(THERMOSTAT_2);
temperatureReset.set(temperature.get(THERMOSTAT_1) == 0 && temperature.get(THERMOSTAT_2) == 0);
Thread.sleep(5 * 1000);
}
}
}).start();
}
initializeAndProvisionDevice 方法说明设备如何使用 DPS 注册并连接到 IoT Central。 有效负载包括 IoT Central 用于将设备分配到设备模板的模型 ID：
private static void initializeAndProvisionDevice() throws Exception {
SecurityProviderSymmetricKey securityClientSymmetricKey = new SecurityProviderSymmetricKey(deviceSymmetricKey.getBytes(), registrationId);
ProvisioningDeviceClient provisioningDeviceClient;
ProvisioningStatus provisioningStatus = new ProvisioningStatus();
provisioningDeviceClient = ProvisioningDeviceClient.create(globalEndpoint, scopeId, provisioningProtocol, securityClientSymmetricKey);
AdditionalData additionalData = new AdditionalData();
additionalData.setProvisioningPayload(com.microsoft.azure.sdk.iot.provisioning.device.plugandplay.PnpHelper.createDpsPayload(MODEL_ID));
ProvisioningDeviceClientRegistrationResult registrationResult = provisioningDeviceClient.registerDeviceSync(additionalData);
ClientOptions options = ClientOptions.builder().modelId(MODEL_ID).build();
if (registrationResult.getProvisioningDeviceClientStatus() == ProvisioningDeviceClientStatus.PROVISIONING_DEVICE_STATUS_ASSIGNED) {
System.out.println("IotHUb Uri : " + registrationResult.getIothubUri());
System.out.println("Device ID : " + registrationResult.getDeviceId());
String iotHubUri = registrationResult.getIothubUri();
String deviceId = registrationResult.getDeviceId();
log.debug("Opening the device client.");
deviceClient = new DeviceClient(iotHubUri, deviceId, securityClientSymmetricKey, IotHubClientProtocol.MQTT, options);
deviceClient.open(true);
}
}
sendTemperatureTelemetry 方法显示设备如何将温度遥测数据从组件发送到 IoT Central。 此方法使用 PnpConvention 类创建消息：
private static void sendTemperatureTelemetry(String componentName) {
String telemetryName = "temperature";
double currentTemperature = temperature.get(componentName);
Message message = PnpConvention.createIotHubMessageUtf8(telemetryName, currentTemperature, componentName);
deviceClient.sendEventAsync(message, new MessageIotHubEventCallback(), message);
// Add the current temperature entry to the list of temperature readings.
Map<Date, Double> currentReadings;
if (temperatureReadings.containsKey(componentName)) {
currentReadings = temperatureReadings.get(componentName);
} else {
currentReadings = new HashMap<>();
}
currentReadings.put(new Date(), currentTemperature);
temperatureReadings.put(componentName, currentReadings);
}
updateMaxTemperatureSinceLastReboot 方法将 maxTempSinceLastReboot 属性更新从组件发送到 IoT Central。 此方法使用 PnpConvention 类创建补丁：
private static void updateMaxTemperatureSinceLastReboot(String componentName) throws IOException {
String propertyName = "maxTempSinceLastReboot";
double maxTemp = maxTemperature.get(componentName);
TwinCollection reportedProperty = PnpConvention.createComponentPropertyPatch(propertyName, maxTemp, componentName);
deviceClient.updateReportedPropertiesAsync(reportedProperty, sendReportedPropertiesResponseCallback, null);
log.debug("Property: Update - {\"{}\": {}°C} is {}.", propertyName, maxTemp, StatusCode.COMPLETED);
}
TargetTemperatureUpdateCallback 类包含为组件处理 IoT Central 中可写属性更新的 onPropertyChanged 方法。 此方法使用 PnpConvention 类创建响应：
private static class TargetTemperatureUpdateCallback
{
final static String propertyName = "targetTemperature";
@SneakyThrows(InterruptedException.class)
public static void onPropertyChanged(Property property, Object context) {
String componentName = (String) context;
if (property.getKey().equalsIgnoreCase(componentName)) {
double targetTemperature = (double) ((TwinCollection) property.getValue()).get(propertyName);
log.debug("Property: Received - component=\"{}\", {\"{}\": {}°C}.", componentName, propertyName, targetTemperature);
TwinCollection pendingPropertyPatch = PnpConvention.createComponentWritablePropertyResponse(
propertyName,
targetTemperature,
componentName,
StatusCode.IN_PROGRESS.value,
property.getVersion().longValue(),
null);
deviceClient.updateReportedPropertiesAsync(pendingPropertyPatch, sendReportedPropertiesResponseCallback, null);
log.debug("Property: Update - component=\"{}\", {\"{}\": {}°C} is {}", componentName, propertyName, targetTemperature, StatusCode.IN_PROGRESS);
// Update temperature in 2 steps
double step = (targetTemperature - temperature.get(componentName)) / 2;
for (int i = 1; i <=2; i++) {
temperature.put(componentName, BigDecimal.valueOf(temperature.get(componentName) + step).setScale(1, RoundingMode.HALF_UP).doubleValue());
Thread.sleep(5 * 1000);
}
TwinCollection completedPropertyPatch = PnpConvention.createComponentWritablePropertyResponse(
propertyName,
temperature.get(componentName),
componentName,
StatusCode.COMPLETED.value,
property.getVersion().longValue(),
"Successfully updated target temperature.");
deviceClient.updateReportedPropertiesAsync(completedPropertyPatch, sendReportedPropertiesResponseCallback, null);
log.debug("Property: Update - {\"{}\": {}°C} is {}", propertyName, temperature.get(componentName), StatusCode.COMPLETED);
} else {
log.debug("Property: Received an unrecognized property update from service.");
}
}
}
MethodCallback 类包含处理从 IoT Central 中调用的组件命令的 onMethodInvoked 方法：
private static class MethodCallback implements com.microsoft.azure.sdk.iot.device.twin.MethodCallback
{
final String reboot = "reboot";
final String getMaxMinReport1 = "thermostat1*getMaxMinReport";
final String getMaxMinReport2 = "thermostat2*getMaxMinReport";
@SneakyThrows(InterruptedException.class)
@Override
public DirectMethodResponse onMethodInvoked(String methodName, DirectMethodPayload methodData, Object context) {
String jsonRequest = methodData.getPayload(String.class);
switch (methodName) {
case reboot:
int delay = getCommandRequestValue(jsonRequest, Integer.class);
log.debug("Command: Received - Rebooting thermostat (resetting temperature reading to 0°C after {} seconds).", delay);
Thread.sleep(delay * 1000L);
temperature.put(THERMOSTAT_1, 0.0d);
temperature.put(THERMOSTAT_2, 0.0d);
maxTemperature.put(THERMOSTAT_1, 0.0d);
maxTemperature.put(THERMOSTAT_2, 0.0d);
temperatureReadings.clear();
return new DirectMethodResponse(StatusCode.COMPLETED.value, null);
case getMaxMinReport1:
case getMaxMinReport2:
String[] words = methodName.split("\\*");
String componentName = words[0];
if (temperatureReadings.containsKey(componentName)) {
Date since = getCommandRequestValue(jsonRequest, Date.class);
log.debug("Command: Received - component=\"{}\", generating min, max, avg temperature report since {}", componentName, since);
Map<Date, Double> allReadings = temperatureReadings.get(componentName);
Map<Date, Double> filteredReadings = allReadings.entrySet().stream()
.filter(map -> map.getKey().after(since))
.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
if (!filteredReadings.isEmpty()) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'");
double maxTemp = Collections.max(filteredReadings.values());
double minTemp = Collections.min(filteredReadings.values());
double avgTemp = filteredReadings.values().stream().mapToDouble(Double::doubleValue).average().orElse(Double.NaN);
String startTime = sdf.format(Collections.min(filteredReadings.keySet()));
String endTime = sdf.format(Collections.max(filteredReadings.keySet()));
String responsePayload = String.format(
"{\"maxTemp\": %.1f, \"minTemp\": %.1f, \"avgTemp\": %.1f, \"startTime\": \"%s\", \"endTime\": \"%s\"}",
maxTemp,
minTemp,
avgTemp,
startTime,
endTime);
log.debug("Command: MaxMinReport since {}: \"maxTemp\": {}°C, \"minTemp\": {}°C, \"avgTemp\": {}°C, \"startTime\": {}, \"endTime\": {}",
since,
maxTemp,
minTemp,
avgTemp,
startTime,
endTime);
return new DirectMethodResponse(StatusCode.COMPLETED.value, responsePayload);
}
log.debug("Command: component=\"{}\", no relevant readings found since {}, cannot generate any report.", componentName, since);
return new DirectMethodResponse(StatusCode.NOT_FOUND.value, null);
}
log.debug("Command: component=\"{}\", no temperature readings sent yet, cannot generate any report.", componentName);
return new DirectMethodResponse(StatusCode.NOT_FOUND.value, null);
default:
log.debug("Command: command=\"{}\" is not implemented, no action taken.", methodName);
return new DirectMethodResponse(StatusCode.NOT_FOUND.value, null);
}
}
}
获取连接信息
在本教程的后面部分中运行示例设备应用程序时，需要以下配置值：
- ID 范围：在 IoT Central 应用程序中，导航到“权限”“设备连接组”。 记下“ID 范围”值。
- 组主键：在 IoT Central 应用程序中，导航到“权限”“设备连接组”>“SAS-IoT-Devices”。 记下共享访问签名主键值。
使用 Azure Cloud Shell 从检索的组主键生成设备密钥：
az extension add --name azure-iot
az iot central device compute-device-key --device-id sample-device-01 --pk <the group primary key value>
记下生成的设备密钥，本教程的后面部分中将用到它。
注意
若要运行此示例，无需在 IoT Central 应用程序中提前注册设备。 此示例使用 IoT Central 功能在首次连接时自动注册设备。
在 Windows 上，导航到下载的适用于 Azure IoT SDK 的 Java 存储库根文件夹。
运行以下命令以生成示例应用程序：
mvn install -T 2C -DskipTests
运行代码
若要运行示例应用程序，请打开一个命令行环境，并导航到包含 src 文件夹和 TemperatureController.java 示例文件的 azure-iot-sdk-java/iothub/device/iot-device-samples/pnp-device-sample/temperature-controller-device-sample 文件夹。
设置环境变量以配置示例。 以下代码片段演示如何在 Windows 命令提示符下设置环境变量。 如果使用 bash shell，请将 命令替换为 export 命令：
set IOTHUB_DEVICE_SECURITY_TYPE=DPS
set IOTHUB_DEVICE_DPS_ID_SCOPE=<The ID scope you made a note of previously>
set IOTHUB_DEVICE_DPS_DEVICE_ID=sample-device-01
set IOTHUB_DEVICE_DPS_DEVICE_KEY=<The generated device key you made a note of previously>
set IOTHUB_DEVICE_DPS_ENDPOINT=global.azure-devices-provisioning.net
运行示例：
mvn exec:java -Dexec.mainClass="samples.com.microsoft.azure.sdk.iot.device.TemperatureController"
以下输出显示设备注册并连接到 IoT Central。 示例开始发送遥测：
2021-03-30 15:33:25.138 DEBUG TemperatureController:123 - Initialize the device client.
Waiting for Provisioning Service to register
Waiting for Provisioning Service to register
IotHUb Uri : iotc-60a.....azure-devices.net
Device ID : sample-device-01
2021-03-30 15:33:38.294 DEBUG TemperatureController:247 - Opening the device client.
2021-03-30 15:33:38.307 INFO ExponentialBackoffWithJitter:98 - NOTE: A new instance of ExponentialBackoffWithJitter has been created with the following properties. Retry Count: 2147483647, Min Backoff Interval: 100, Max Backoff Interval: 10000, Max Time Between Retries: 100, Fast Retry Enabled: true
2021-03-30 15:33:38.321 INFO ExponentialBackoffWithJitter:98 - NOTE: A new instance of ExponentialBackoffWithJitter has been created with the following properties. Retry Count: 2147483647, Min Backoff Interval: 100, Max Backoff Interval: 10000, Max Time Between Retries: 100, Fast Retry Enabled: true
2021-03-30 15:33:38.427 DEBUG MqttIotHubConnection:274 - Opening MQTT connection...
2021-03-30 15:33:38.427 DEBUG Mqtt:123 - Sending MQTT CONNECT packet...
2021-03-30 15:33:44.628 DEBUG Mqtt:126 - Sent MQTT CONNECT packet was acknowledged
2021-03-30 15:33:44.630 DEBUG Mqtt:256 - Sending MQTT SUBSCRIBE packet for topic devices/sample-device-01/messages/devicebound/#
2021-03-30 15:33:44.731 DEBUG Mqtt:261 - Sent MQTT SUBSCRIBE packet for topic devices/sample-device-01/messages/devicebound/# was acknowledged
2021-03-30 15:33:44.733 DEBUG MqttIotHubConnection:279 - MQTT connection opened successfully
2021-03-30 15:33:44.733 DEBUG IotHubTransport:302 - The connection to the IoT Hub has been established
2021-03-30 15:33:44.734 INFO IotHubTransport:1429 - Updating transport status to new status CONNECTED with reason CONNECTION_OK
2021-03-30 15:33:44.735 DEBUG IotHubTransport:1439 - Invoking connection status callbacks with new status details
2021-03-30 15:33:44.739 DEBUG IotHubTransport:394 - Client connection opened successfully
2021-03-30 15:33:44.740 INFO DeviceClient:438 - Device client opened successfully
2021-03-30 15:33:44.740 DEBUG TemperatureController:152 - Set handler for "reboot" command.
2021-03-30 15:33:44.742 DEBUG TemperatureController:153 - Set handler for "getMaxMinReport" command.
2021-03-30 15:33:44.774 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [029d30d4-acbd-462d-b155-82d53ce7786c] Message Id [1b2adf93-ba81-41e4-b8c7-7c90c8b0d6a1] Device Operation Type [DEVICE_OPERATION_METHOD_SUBSCRIBE_REQUEST] )
2021-03-30 15:33:44.774 DEBUG TemperatureController:156 - Set handler to receive "targetTemperature" updates.
2021-03-30 15:33:44.775 INFO IotHubTransport:1344 - Sending message ( Message details: Correlation Id [029d30d4-acbd-462d-b155-82d53ce7786c] Message Id [1b2adf93-ba81-41e4-b8c7-7c90c8b0d6a1] Device Operation Type [DEVICE_OPERATION_METHOD_SUBSCRIBE_REQUEST] )
2021-03-30 15:33:44.779 DEBUG Mqtt:256 - Sending MQTT SUBSCRIBE packet for topic $iothub/methods/POST/#
2021-03-30 15:33:44.793 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [f2f9ed95-9778-44f2-b9ec-f60c84061251] Message Id [0d5abdb2-6460-414c-a10e-786ee24cacff] Device Operation Type [DEVICE_OPERATION_TWIN_SUBSCRIBE_DESIRED_PROPERTIES_REQUEST] )
2021-03-30 15:33:44.794 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [417d659a-7324-43fa-84eb-8a3f3d07963c] Message Id [55532cad-8a5a-489f-9aa8-8f0e5bc21541] Request Id [0] Device Operation Type [DEVICE_OPERATION_TWIN_GET_REQUEST] )
2021-03-30 15:33:44.819 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [d46a0d8a-8a18-4014-abeb-768bd9b17ad2] Message Id [780abc81-ce42-4e5f-aa80-e4785883604e] Device Operation Type [DEVICE_OPERATION_TWIN_SUBSCRIBE_DESIRED_PROPERTIES_REQUEST] )
2021-03-30 15:33:44.881 DEBUG Mqtt:261 - Sent MQTT SUBSCRIBE packet for topic $iothub/methods/POST/# was acknowledged
2021-03-30 15:33:44.882 INFO IotHubTransport:1344 - Sending message ( Message details: Correlation Id [f2f9ed95-9778-44f2-b9ec-f60c84061251] Message Id [0d5abdb2-6460-414c-a10e-786ee24cacff] Device Operation Type [DEVICE_OPERATION_TWIN_SUBSCRIBE_DESIRED_PROPERTIES_REQUEST] )
2021-03-30 15:33:44.882 DEBUG Mqtt:256 - Sending MQTT SUBSCRIBE packet for topic $iothub/twin/res/#
2021-03-30 15:33:44.893 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [a77b1c02-f043-4477-b610-e31a774772c0] Message Id [2e2f6bee-c480-42cf-ac31-194118930846] Request Id [1] Device Operation Type [DEVICE_OPERATION_TWIN_UPDATE_REPORTED_PROPERTIES_REQUEST] )
2021-03-30 15:33:44.904 DEBUG TemperatureController:423 - Property: Update - component = "deviceInformation" is COMPLETED.
2021-03-30 15:33:44.915 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [bbb7e3cf-3550-4fdf-90f9-0787740f028a] Message Id [e06ac385-ae0d-46dd-857a-d9725707527a] )
2021-03-30 15:33:44.915 DEBUG TemperatureController:434 - Telemetry: Sent - {"workingSet": 1024.0KiB }
2021-03-30 15:33:44.915 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [6dbef765-cc9a-4e72-980a-2fe5b0cd77e1] Message Id [49bbad33-09bf-417a-9d6e-299ba7b7c562] Request Id [2] Device Operation Type [DEVICE_OPERATION_TWIN_UPDATE_REPORTED_PROPERTIES_REQUEST] )
2021-03-30 15:33:44.916 DEBUG TemperatureController:442 - Property: Update - {"serialNumber": SR-123456} is COMPLETED
2021-03-30 15:33:44.927 INFO IotHubTransport:489 - Message was queued to be sent later ( Message details: Correlation Id [86787c32-87a5-4c49-9083-c7f2b17446a7] Message Id [0a45fa0c-a467-499d-b214-9bb5995772ba] )
2021-03-30 15:33:44.927 DEBUG TemperatureController:461 - Telemetry: Sent - {"temperature": 5.8°C} with message Id 0a45fa0c-a467-499d-b214-9bb5995772ba.
Azure IoT Central 应用程序中的操作员可以：
在“概述”页上查看两个恒温组件发送的遥测数据：
在“关于”页上查看设备属性。 此页显示设备信息组件和两个恒温器组件的属性：
自定义设备模板
作为解决方案开发人员，你可以对 IoT Central 在温度控制器设备连接时自动创建的设备模板进行自定义。
添加云属性以存储与设备关联的客户名称：
在 IoT Central 应用程序中，导航到“设备模板”页面上的“温度控制器”设备模板 。
在“温度控制器”模型中，选择“+添加功能”。
输入“客户名称”作为“显示名称”，选择“云属性”作为“功能类型”，然后扩展条目并选择“字符串”作为“架构”。 再选择“保存”。
若要自定义“获取最高-最低温度报告”命令在 IoT Central 应用程序中的显示方式，请按照以下说明操作：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“getMaxMinReport (thermostat1)”，请将“获取最高-最低温度报告”替换为“获取 thermostat1 状态报告”。
对于“getMaxMinReport (thermostat2)”，请将“获取最高-最低温度报告”替换为“获取 thermostat2 状态报告”。
选择“保存”。
若要自定义“目标温度”可写属性在 IoT Central 应用程序中的显示方式：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“targetTemperature (thermostat1)”，请将“目标温度”替换为“目标温度 (1)”。
对于“targetTemperature (thermostat2)”，请将“目标温度”替换为“目标温度 (2)”。
选择“保存”。
“温度控制器”模型中的恒温器组件包含“目标温度”可写属性，设备模板包含“客户名称”云属性。 操作员可以使用“创建视图”来编辑以下属性：
选择“视图”，然后选择“编辑设备和云数据”磁贴。
输入“属性”作为窗体名称。
选择“目标温度(1)”、“目标温度(2)”和“客户名称”属性。 然后选择“添加部分”。
保存所做更改。
发布设备模板
必须先发布设备模板，操作员才能查看和使用你进行的自定义。
从“恒温器”设备模板中，选择“发布”。 在“将此设备模板发布到应用程序”面板中，选择“发布”。
操作员现在可以使用“属性”视图来更新属性值，并在设备命令页上调用“获取恒温器 1 状态报告”和“获取恒温器 2 状态报告”的命令：
更新“属性”页上的可写属性值：
从“命令”页中调用命令。 如果运行状态报告命令，请在运行该命令之前为参数“自”选择一个日期和时间：
可以看到设备如何对命令和属性更新做出响应：
2021-03-30 15:43:57.133 DEBUG TemperatureController:309 - Command: Received - component="thermostat1", generating min, max, avg temperature report since Tue Mar 30 06:00:00 BST 2021
2021-03-30 15:43:57.153 DEBUG TemperatureController:332 - Command: MaxMinReport since Tue Mar 30 06:00:00 BST 2021: "maxTemp": 35.6°C, "minTemp": 35.6°C, "avgTemp": 35.6°C, "startTime": 2021-03-30T15:43:41Z, "endTime": 2021-03-30T15:43:56Z
2021-03-30 15:43:57.394 DEBUG TemperatureController:502 - Command - Response from IoT Hub: command name=null, status=OK_EMPTY
...
2021-03-30 15:48:47.808 DEBUG TemperatureController:372 - Property: Received - component="thermostat2", {"targetTemperature": 67.0°C}.
2021-03-30 15:48:47.837 DEBUG TemperatureController:382 - Property: Update - component="thermostat2", {"targetTemperature": 67.0°C} is IN_PROGRESS
先决条件
若要完成本文中的步骤，需要准备好以下资源：
一个有效的 Azure 订阅。 如果没有 Azure 订阅，请在开始之前创建一个免费帐户。
根据自定义应用程序模板创建的 IoT Central 应用程序。 若要了解详细信息，请参阅创建 IoT Central 应用程序和关于你的应用程序。
安装了 Node.js 6 或更高版本的开发计算机。 若要检查版本，可以在命令行中运行
node --version。 本教程中的说明假设在 Windows 命令提示符下运行 node 命令。 但是，可以在许多其他的操作系统上使用 Node.js。适用于 Node.js 的 Microsoft Azure IoT SDK GitHub 存储库（包含示例代码）的本地副本。 使用此链接下载存储库副本：下载 ZIP。 然后将该文件解压缩到本地计算机上的适当位置。
查看代码
在之前下载的 Microsoft Azure IoT SDK for Node.js 的副本中，使用文本编辑器打开 azure-iot-sdk-node/device/samples/javascript/pnp_temperature_controller.js 文件。
此示例实现多组件温度控制器数字孪生体定义语言模型。
当你运行连接到 IoT Central 的示例时，它将使用设备预配服务 (DPS) 来注册设备并生成连接字符串。 该示例从命令行环境中检索其所需的 DPS 连接信息。
main 方法：
- 在打开连接之前，创建
client对象并设置dtmi:com:example:TemperatureController;2模型 ID。 IoT Central 使用模型 ID 识别或生成此设备的设备模板。 若要了解详细信息，请参阅将设备分配到设备模板。 - 为三个命令创建命令处理程序。
- 为每个恒温器组件启动一个循环，每隔 5 秒发送一次温度遥测数据。
- 启动默认组件的循环，每隔 6 秒发送一次工作集大小遥测数据。
- 为每个恒温器组件发送
maxTempSinceLastReboot属性。 - 发送设备信息属性。
- 为三个组件创建可写属性处理程序。
async function main() {
// ...
// fromConnectionString must specify a transport, coming from any transport package.
const client = Client.fromConnectionString(deviceConnectionString, Protocol);
console.log('Connecting using connection string: ' + deviceConnectionString);
let resultTwin;
try {
// Add the modelId here
await client.setOptions(modelIdObject);
await client.open();
console.log('Enabling the commands on the client');
client.onDeviceMethod(commandNameGetMaxMinReport1, commandHandler);
client.onDeviceMethod(commandNameGetMaxMinReport2, commandHandler);
client.onDeviceMethod(commandNameReboot, commandHandler);
// Send Telemetry after some interval
let index1 = 0;
let index2 = 0;
let index3 = 0;
intervalToken1 = setInterval(() => {
const data = JSON.stringify(thermostat1.updateSensor().getCurrentTemperatureObject());
sendTelemetry(client, data, index1, thermostat1ComponentName).catch((err) => console.log('error ', err.toString()));
index1 += 1;
}, 5000);
intervalToken2 = setInterval(() => {
const data = JSON.stringify(thermostat2.updateSensor().getCurrentTemperatureObject());
sendTelemetry(client, data, index2, thermostat2ComponentName).catch((err) => console.log('error ', err.toString()));
index2 += 1;
}, 5500);
intervalToken3 = setInterval(() => {
const data = JSON.stringify({ workingset: 1 + (Math.random() * 90) });
sendTelemetry(client, data, index3, null).catch((err) => console.log('error ', err.toString()));
index3 += 1;
}, 6000);
// attach a standard input exit listener
exitListener(client);
try {
resultTwin = await client.getTwin();
// Only report readable properties
const patchRoot = helperCreateReportedPropertiesPatch({ serialNumber: serialNumber }, null);
const patchThermostat1Info = helperCreateReportedPropertiesPatch({
maxTempSinceLastReboot: thermostat1.getMaxTemperatureValue(),
}, thermostat1ComponentName);
const patchThermostat2Info = helperCreateReportedPropertiesPatch({
maxTempSinceLastReboot: thermostat2.getMaxTemperatureValue(),
}, thermostat2ComponentName);
const patchDeviceInfo = helperCreateReportedPropertiesPatch({
manufacturer: 'Contoso Device Corporation',
model: 'Contoso 47-turbo',
swVersion: '10.89',
osName: 'Contoso_OS',
processorArchitecture: 'Contoso_x86',
processorManufacturer: 'Contoso Industries',
totalStorage: 65000,
totalMemory: 640,
}, deviceInfoComponentName);
// the below things can only happen once the twin is there
updateComponentReportedProperties(resultTwin, patchRoot, null);
updateComponentReportedProperties(resultTwin, patchThermostat1Info, thermostat1ComponentName);
updateComponentReportedProperties(resultTwin, patchThermostat2Info, thermostat2ComponentName);
updateComponentReportedProperties(resultTwin, patchDeviceInfo, deviceInfoComponentName);
desiredPropertyPatchListener(resultTwin, [thermostat1ComponentName, thermostat2ComponentName, deviceInfoComponentName]);
} catch (err) {
console.error('could not retrieve twin or report twin properties\n' + err.toString());
}
} catch (err) {
console.error('could not connect Plug and Play client or could not attach interval function for telemetry\n' + err.toString());
}
}
provisionDevice 函数显示设备如何使用 DPS 注册并连接到 IoT Central。 有效负载包括 IoT Central 用于将设备分配到设备模板的模型 ID：
async function provisionDevice(payload) {
var provSecurityClient = new SymmetricKeySecurityClient(registrationId, symmetricKey);
var provisioningClient = ProvisioningDeviceClient.create(provisioningHost, idScope, new ProvProtocol(), provSecurityClient);
if (payload) {
provisioningClient.setProvisioningPayload(payload);
}
try {
let result = await provisioningClient.register();
deviceConnectionString = 'HostName=' + result.assignedHub + ';DeviceId=' + result.deviceId + ';SharedAccessKey=' + symmetricKey;
console.log('registration succeeded');
console.log('assigned hub=' + result.assignedHub);
console.log('deviceId=' + result.deviceId);
console.log('payload=' + JSON.stringify(result.payload));
} catch (err) {
console.error("error registering device: " + err.toString());
}
}
sendTelemetry 函数显示设备如何将温度遥测发送到 IoT Central。 对于来自组件的遥测数据，它使用组件名称添加一个名为 $.sub 的属性：
async function sendTelemetry(deviceClient, data, index, componentName) {
if componentName) {
console.log('Sending telemetry message %d from component: %s ', index, componentName);
} else {
console.log('Sending telemetry message %d from root interface', index);
}
const msg = new Message(data);
if (componentName) {
msg.properties.add(messageSubjectProperty, componentName);
}
msg.contentType = 'application/json';
msg.contentEncoding = 'utf-8';
await deviceClient.sendEvent(msg);
}
main 方法使用调用的帮助器方法 helperCreateReportedPropertiesPatch 来创建属性更新消息。 此方法采用一个可选参数来指定发送属性的组件：
const helperCreateReportedPropertiesPatch = (propertiesToReport, componentName) => {
let patch;
if (!!(componentName)) {
patch = { };
propertiesToReport.__t = 'c';
patch[componentName] = propertiesToReport;
} else {
patch = { };
patch = propertiesToReport;
}
if (!!(componentName)) {
console.log('The following properties will be updated for component: ' + componentName);
} else {
console.log('The following properties will be updated for root interface.');
}
console.log(patch);
return patch;
};
main 方法使用以下方法来处理对 IoT Central 中可写属性的更新。 注意方法如何生成包含版本和状态代码的响应：
const desiredPropertyPatchListener = (deviceTwin, componentNames) => {
deviceTwin.on('properties.desired', (delta) => {
console.log('Received an update for device with value: ' + JSON.stringify(delta));
Object.entries(delta).forEach(([key, values]) => {
const version = delta.$version;
if (!!(componentNames) && componentNames.includes(key)) { // then it is a component we are expecting
const componentName = key;
const patchForComponents = { [componentName]: {} };
Object.entries(values).forEach(([propertyName, propertyValue]) => {
if (propertyName !== '__t' && propertyName !== '$version') {
console.log('Will update property: ' + propertyName + ' to value: ' + propertyValue + ' of component: ' + componentName);
const propertyContent = { value: propertyValue };
propertyContent.ac = 200;
propertyContent.ad = 'Successfully executed patch';
propertyContent.av = version;
patchForComponents[componentName][propertyName] = propertyContent;
}
});
updateComponentReportedProperties(deviceTwin, patchForComponents, componentName);
}
else if (key !== '$version') { // individual property for root
const patchForRoot = { };
console.log('Will update property: ' + key + ' to value: ' + values + ' for root');
const propertyContent = { value: values };
propertyContent.ac = 200;
propertyContent.ad = 'Successfully executed patch';
propertyContent.av = version;
patchForRoot[key] = propertyContent;
updateComponentReportedProperties(deviceTwin, patchForRoot, null);
}
});
});
};
main 方法使用以下方法来处理来自 IoT Central的 命令：
const commandHandler = async (request, response) => {
helperLogCommandRequest(request);
switch (request.methodName) {
case commandNameGetMaxMinReport1: {
await sendCommandResponse(request, response, 200, thermostat1.getMaxMinReportObject());
break;
}
case commandNameGetMaxMinReport2: {
await sendCommandResponse(request, response, 200, thermostat2.getMaxMinReportObject());
break;
}
case commandNameReboot: {
await sendCommandResponse(request, response, 200, 'reboot response');
break;
}
default:
await sendCommandResponse(request, response, 404, 'unknown method');
break;
}
};
const sendCommandResponse = async (request, response, status, payload) => {
try {
await response.send(status, payload);
console.log('Response to method: ' + request.methodName + ' sent successfully.' );
} catch (err) {
console.error('An error occurred when sending a method response:\n' + err.toString());
}
};
获取连接信息
在本教程的后面部分中运行示例设备应用程序时，需要以下配置值：
- ID 范围：在 IoT Central 应用程序中，导航到“权限”“设备连接组”。 记下“ID 范围”值。
- 组主键：在 IoT Central 应用程序中，导航到“权限”“设备连接组”>“SAS-IoT-Devices”。 记下共享访问签名主键值。
使用 Azure Cloud Shell 从检索的组主键生成设备密钥：
az extension add --name azure-iot
az iot central device compute-device-key --device-id sample-device-01 --pk <the group primary key value>
记下生成的设备密钥，本教程的后面部分中将用到它。
注意
若要运行此示例，无需在 IoT Central 应用程序中提前注册设备。 此示例使用 IoT Central 功能在首次连接时自动注册设备。
运行代码
若要运行示例应用程序，请打开命令行环境并导航到包含 pnp_temperature_controller.js 示例文件的 azure-iot-sdk-node/device/samples/javascript 文件夹。
设置环境变量以配置示例。 以下代码片段演示如何在 Windows 命令提示符下设置环境变量。 如果使用 bash shell，请将 命令替换为 export 命令：
set IOTHUB_DEVICE_SECURITY_TYPE=DPS
set IOTHUB_DEVICE_DPS_ID_SCOPE=<The ID scope you made a note of previously>
set IOTHUB_DEVICE_DPS_DEVICE_ID=sample-device-01
set IOTHUB_DEVICE_DPS_DEVICE_KEY=<The generated device key you made a note of previously>
set IOTHUB_DEVICE_DPS_ENDPOINT=global.azure-devices-provisioning.net
安装所需的包：
npm install
运行示例：
node pnp_temperature_controller.js
以下输出显示设备注册并连接到 IoT Central。 该示例先发送两个恒温器组件的“maxTempSinceLastReboot”属性，然后才开始发送遥测数据：
registration succeeded
assigned hub=iotc-....azure-devices.net
deviceId=sample-device-01
payload=undefined
Connecting using connection string: HostName=iotc-....azure-devices.net;DeviceId=sample-device-01;SharedAccessKey=qdv...IpAo=
Enabling the commands on the client
Please enter q or Q to exit sample.
The following properties will be updated for root interface.
{ serialNumber: 'alwinexlepaho8329' }
The following properties will be updated for component: thermostat1
{ thermostat1: { maxTempSinceLastReboot: 1.5902294191855972, __t: 'c' } }
The following properties will be updated for component: thermostat2
{ thermostat2: { maxTempSinceLastReboot: 16.181771928614545, __t: 'c' } }
The following properties will be updated for component: deviceInformation
{ deviceInformation:
{ manufacturer: 'Contoso Device Corporation',
model: 'Contoso 47-turbo',
swVersion: '10.89',
osName: 'Contoso_OS',
processorArchitecture: 'Contoso_x86',
processorManufacturer: 'Contoso Industries',
totalStorage: 65000,
totalMemory: 640,
__t: 'c' } }
executed sample
Received an update for device with value: {"$version":1}
Properties have been reported for component: thermostat1
Properties have been reported for component: thermostat2
Properties have been reported for component: deviceInformation
Properties have been reported for root interface.
Sending telemetry message 0 from component: thermostat1
Sending telemetry message 0 from component: thermostat2
Sending telemetry message 0 from root interface
Azure IoT Central 应用程序中的操作员可以：
在“概述”页上查看两个恒温组件发送的遥测数据：
在“关于”页上查看设备属性。 此页显示设备信息组件和两个恒温器组件的属性：
自定义设备模板
作为解决方案开发人员，你可以对 IoT Central 在温度控制器设备连接时自动创建的设备模板进行自定义。
添加云属性以存储与设备关联的客户名称：
在 IoT Central 应用程序中，导航到“设备模板”页面上的“温度控制器”设备模板 。
在“温度控制器”模型中，选择“+添加功能”。
输入“客户名称”作为“显示名称”，选择“云属性”作为“功能类型”，然后扩展条目并选择“字符串”作为“架构”。 再选择“保存”。
若要自定义“获取最高-最低温度报告”命令在 IoT Central 应用程序中的显示方式，请按照以下说明操作：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“getMaxMinReport (thermostat1)”，请将“获取最高-最低温度报告”替换为“获取 thermostat1 状态报告”。
对于“getMaxMinReport (thermostat2)”，请将“获取最高-最低温度报告”替换为“获取 thermostat2 状态报告”。
选择“保存”。
若要自定义“目标温度”可写属性在 IoT Central 应用程序中的显示方式：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“targetTemperature (thermostat1)”，请将“目标温度”替换为“目标温度 (1)”。
对于“targetTemperature (thermostat2)”，请将“目标温度”替换为“目标温度 (2)”。
选择“保存”。
“温度控制器”模型中的恒温器组件包含“目标温度”可写属性，设备模板包含“客户名称”云属性。 操作员可以使用“创建视图”来编辑以下属性：
选择“视图”，然后选择“编辑设备和云数据”磁贴。
输入“属性”作为窗体名称。
选择“目标温度(1)”、“目标温度(2)”和“客户名称”属性。 然后选择“添加部分”。
保存所做更改。
发布设备模板
必须先发布设备模板，操作员才能查看和使用你进行的自定义。
从“恒温器”设备模板中，选择“发布”。 在“将此设备模板发布到应用程序”面板中，选择“发布”。
操作员现在可以使用“属性”视图来更新属性值，并在设备命令页上调用“获取恒温器 1 状态报告”和“获取恒温器 2 状态报告”的命令：
更新“属性”页上的可写属性值：
从“命令”页中调用命令。 如果运行状态报告命令，请在运行该命令之前为参数“自”选择一个日期和时间：
你可以看到设备如何响应命令和属性更新。 此 getMaxMinReport 命令在 thermostat2 组件中，而 reboot 命令在默认组件中。 系统为 thermostat2 组件设置了 targetTemperature 可写属性：
Received command request for command name: thermostat2*getMaxMinReport
The command request payload is:
2021-03-26T06:00:00.000Z
Response to method: thermostat2*getMaxMinReport sent successfully.
...
Received command request for command name: reboot
The command request payload is:
10
Response to method: reboot sent successfully.
...
Received an update for device with value: {"thermostat2":{"targetTemperature":76,"__t":"c"},"$version":2}
Will update property: targetTemperature to value: 76 of component: thermostat2
Properties have been reported for component: thermostat2
先决条件
若要完成本文中的步骤，需要准备好以下资源：
一个有效的 Azure 订阅。 如果没有 Azure 订阅，请在开始之前创建一个免费帐户。
根据自定义应用程序模板创建的 IoT Central 应用程序。 若要了解详细信息，请参阅创建 IoT Central 应用程序和关于你的应用程序。
装有 Python 的开发计算机。 查看 Azure IoT Python SDK 以了解当前的 Python 版本要求。 若要检查版本，可以在命令行中运行
python --version。 Python 适用于各种操作系统。 本教程中的说明假设在 Windows 命令提示符下运行 python 命令。适用于 Python 的 Microsoft Azure IoT SDK GitHub 存储库（包含示例代码）的本地副本。 使用此链接下载存储库副本：下载 ZIP。 然后将该文件解压缩到本地计算机上的适当位置。
查看代码
在先前下载的适用于 Python 的 Microsoft Azure IoT SDK 副本中，使用文本编辑器打开“azure-iot-sdk-python/samples/pnp/temp_controller_with_thermostats.py”文件。
此示例实现多组件温度控制器数字孪生体定义语言模型。
当你运行连接到 IoT Central 的示例时，它将使用设备预配服务 (DPS) 来注册设备并生成连接字符串。 该示例从命令行环境中检索其所需的 DPS 连接信息。
main 函数：
- 使用 DPS 预配设备。 预配信息包括模型 ID。 IoT Central 使用模型 ID 识别或生成此设备的设备模板。 若要了解详细信息，请参阅将设备分配到设备模板。
- 在打开连接之前，创建
Device_client对象并设置dtmi:com:example:TemperatureController;2模型 ID。 - 向 IoT Central 发送初始属性值。 它使用
pnp_helper创建补丁。 - 为
getMaxMinReport和reboot命令创建侦听器。 每个恒温器组件都有专属的getMaxMinReport命令。 - 创建用于侦听可写属性更新的属性侦听器。
- 开始循环，每隔 8 秒从两个恒温器组件发送一次温度遥测数据，以及从默认组件发送一次工作集遥测数据。
async def main():
switch = os.getenv("IOTHUB_DEVICE_SECURITY_TYPE")
if switch == "DPS":
provisioning_host = (
os.getenv("IOTHUB_DEVICE_DPS_ENDPOINT")
if os.getenv("IOTHUB_DEVICE_DPS_ENDPOINT")
else "global.azure-devices-provisioning.net"
)
id_scope = os.getenv("IOTHUB_DEVICE_DPS_ID_SCOPE")
registration_id = os.getenv("IOTHUB_DEVICE_DPS_DEVICE_ID")
symmetric_key = os.getenv("IOTHUB_DEVICE_DPS_DEVICE_KEY")
registration_result = await provision_device(
provisioning_host, id_scope, registration_id, symmetric_key, model_id
)
if registration_result.status == "assigned":
print("Device was assigned")
print(registration_result.registration_state.assigned_hub)
print(registration_result.registration_state.device_id)
device_client = IoTHubDeviceClient.create_from_symmetric_key(
symmetric_key=symmetric_key,
hostname=registration_result.registration_state.assigned_hub,
device_id=registration_result.registration_state.device_id,
product_info=model_id,
)
else:
raise RuntimeError(
"Could not provision device. Aborting Plug and Play device connection."
)
elif switch == "connectionString":
# ...
# Connect the client.
await device_client.connect()
################################################
# Update readable properties from various components
properties_root = pnp_helper.create_reported_properties(serialNumber=serial_number)
properties_thermostat1 = pnp_helper.create_reported_properties(
thermostat_1_component_name, maxTempSinceLastReboot=98.34
)
properties_thermostat2 = pnp_helper.create_reported_properties(
thermostat_2_component_name, maxTempSinceLastReboot=48.92
)
properties_device_info = pnp_helper.create_reported_properties(
device_information_component_name,
swVersion="5.5",
manufacturer="Contoso Device Corporation",
model="Contoso 4762B-turbo",
osName="Mac Os",
processorArchitecture="x86-64",
processorManufacturer="Intel",
totalStorage=1024,
totalMemory=32,
)
property_updates = asyncio.gather(
device_client.patch_twin_reported_properties(properties_root),
device_client.patch_twin_reported_properties(properties_thermostat1),
device_client.patch_twin_reported_properties(properties_thermostat2),
device_client.patch_twin_reported_properties(properties_device_info),
)
################################################
# Get all the listeners running
print("Listening for command requests and property updates")
global THERMOSTAT_1
global THERMOSTAT_2
THERMOSTAT_1 = Thermostat(thermostat_1_component_name, 10)
THERMOSTAT_2 = Thermostat(thermostat_2_component_name, 10)
listeners = asyncio.gather(
execute_command_listener(
device_client, method_name="reboot", user_command_handler=reboot_handler
),
execute_command_listener(
device_client,
thermostat_1_component_name,
method_name="getMaxMinReport",
user_command_handler=max_min_handler,
create_user_response_handler=create_max_min_report_response,
),
execute_command_listener(
device_client,
thermostat_2_component_name,
method_name="getMaxMinReport",
user_command_handler=max_min_handler,
create_user_response_handler=create_max_min_report_response,
),
execute_property_listener(device_client),
)
################################################
# Function to send telemetry every 8 seconds
async def send_telemetry():
print("Sending telemetry from various components")
while True:
curr_temp_ext = random.randrange(10, 50)
THERMOSTAT_1.record(curr_temp_ext)
temperature_msg1 = {"temperature": curr_temp_ext}
await send_telemetry_from_temp_controller(
device_client, temperature_msg1, thermostat_1_component_name
)
curr_temp_int = random.randrange(10, 50) # Current temperature in Celsius
THERMOSTAT_2.record(curr_temp_int)
temperature_msg2 = {"temperature": curr_temp_int}
await send_telemetry_from_temp_controller(
device_client, temperature_msg2, thermostat_2_component_name
)
workingset_msg3 = {"workingSet": random.randrange(1, 100)}
await send_telemetry_from_temp_controller(device_client, workingset_msg3)
send_telemetry_task = asyncio.ensure_future(send_telemetry())
# ...
provision_device 函数使用 DPS 来预配设备并通过 IoT Central 注册设备。 该函数包括设备模型 ID，在预配有效负载中，IoT Central 使用该设备模型 ID 将设备分配到设备模板：
async def provision_device(provisioning_host, id_scope, registration_id, symmetric_key, model_id):
provisioning_device_client = ProvisioningDeviceClient.create_from_symmetric_key(
provisioning_host=provisioning_host,
registration_id=registration_id,
id_scope=id_scope,
symmetric_key=symmetric_key,
)
provisioning_device_client.provisioning_payload = {"modelId": model_id}
return await provisioning_device_client.register()
execute_command_listener 函数处理命令请求，在设备收到有关恒温器组件的 getMaxMinReport 命令时运行 max_min_handler 以及在设备收到 reboot 命令时运行 reboot_handler 函数。 它使用 pnp_helper 模块来生成响应：
async def execute_command_listener(
device_client,
component_name=None,
method_name=None,
user_command_handler=None,
create_user_response_handler=None,
):
while True:
if component_name and method_name:
command_name = component_name + "*" + method_name
elif method_name:
command_name = method_name
else:
command_name = None
command_request = await device_client.receive_method_request(command_name)
print("Command request received with payload")
values = command_request.payload
print(values)
if user_command_handler:
await user_command_handler(values)
else:
print("No handler provided to execute")
(response_status, response_payload) = pnp_helper.create_response_payload_with_status(
command_request, method_name, create_user_response=create_user_response_handler
)
command_response = MethodResponse.create_from_method_request(
command_request, response_status, response_payload
)
try:
await device_client.send_method_response(command_response)
except Exception:
print("responding to the {command} command failed".format(command=method_name))
async def execute_property_listener 处理恒温器组件的可写属性更新（例如 targetTemperature）并生成 JSON 响应。 它使用 pnp_helper 模块来生成响应：
async def execute_property_listener(device_client):
while True:
patch = await device_client.receive_twin_desired_properties_patch() # blocking call
print(patch)
properties_dict = pnp_helper.create_reported_properties_from_desired(patch)
await device_client.patch_twin_reported_properties(properties_dict)
send_telemetry_from_temp_controller 函数将恒温器组件的遥测数据消息发送到 IoT Central。 它使用 pnp_helper 模块来生成消息：
async def send_telemetry_from_temp_controller(device_client, telemetry_msg, component_name=None):
msg = pnp_helper.create_telemetry(telemetry_msg, component_name)
await device_client.send_message(msg)
print("Sent message")
print(msg)
await asyncio.sleep(5)
获取连接信息
在本教程的后面部分中运行示例设备应用程序时，需要以下配置值：
- ID 范围：在 IoT Central 应用程序中，导航到“权限”“设备连接组”。 记下“ID 范围”值。
- 组主键：在 IoT Central 应用程序中，导航到“权限”“设备连接组”>“SAS-IoT-Devices”。 记下共享访问签名主键值。
使用 Azure Cloud Shell 从检索的组主键生成设备密钥：
az extension add --name azure-iot
az iot central device compute-device-key --device-id sample-device-01 --pk <the group primary key value>
记下生成的设备密钥，本教程的后面部分中将用到它。
注意
若要运行此示例，无需在 IoT Central 应用程序中提前注册设备。 此示例使用 IoT Central 功能在首次连接时自动注册设备。
运行代码
若要运行示例应用程序，请打开命令行环境并导航到包含 temp_controller_with_thermostats.py 示例文件的 azure-iot-sdk-python-2/samples/pnp 文件夹。
设置环境变量以配置示例。 以下代码片段演示如何在 Windows 命令提示符下设置环境变量。 如果使用 bash shell，请将 命令替换为 export 命令：
set IOTHUB_DEVICE_SECURITY_TYPE=DPS
set IOTHUB_DEVICE_DPS_ID_SCOPE=<The ID scope you made a note of previously>
set IOTHUB_DEVICE_DPS_DEVICE_ID=sample-device-01
set IOTHUB_DEVICE_DPS_DEVICE_KEY=<The generated device key you made a note of previously>
set IOTHUB_DEVICE_DPS_ENDPOINT=global.azure-devices-provisioning.net
安装所需的包：
pip install azure-iot-device
运行示例：
python temp_controller_with_thermostats.py
以下输出显示设备注册并连接到 IoT Central。 该示例发送两个恒温器组件的 maxTempSinceLastReboot 属性，然后才开始发送遥测数据：
Device was assigned
iotc-60a.....azure-devices.net
sample-device-01
Updating pnp properties for root interface
{'serialNumber': 'alohomora'}
Updating pnp properties for thermostat1
{'thermostat1': {'maxTempSinceLastReboot': 98.34, '__t': 'c'}}
Updating pnp properties for thermostat2
{'thermostat2': {'maxTempSinceLastReboot': 48.92, '__t': 'c'}}
Updating pnp properties for deviceInformation
{'deviceInformation': {'swVersion': '5.5', 'manufacturer': 'Contoso Device Corporation', 'model': 'Contoso 4762B-turbo', 'osName': 'Mac Os', 'processorArchitecture': 'x86-64', 'processorManufacturer': 'Intel', 'totalStorage': 1024, 'totalMemory': 32, '__t': 'c'}}
Listening for command requests and property updates
Press Q to quit
Sending telemetry from various components
Sent message
{"temperature": 27}
Sent message
{"temperature": 17}
Sent message
{"workingSet": 13}
Azure IoT Central 应用程序中的操作员可以：
在“概述”页上查看两个恒温组件发送的遥测数据：
在“关于”页上查看设备属性。 此页显示设备信息组件和两个恒温器组件的属性：
自定义设备模板
作为解决方案开发人员，你可以对 IoT Central 在温度控制器设备连接时自动创建的设备模板进行自定义。
添加云属性以存储与设备关联的客户名称：
在 IoT Central 应用程序中，导航到“设备模板”页面上的“温度控制器”设备模板 。
在“温度控制器”模型中，选择“+添加功能”。
输入“客户名称”作为“显示名称”，选择“云属性”作为“功能类型”，然后扩展条目并选择“字符串”作为“架构”。 再选择“保存”。
若要自定义“获取最高-最低温度报告”命令在 IoT Central 应用程序中的显示方式，请按照以下说明操作：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“getMaxMinReport (thermostat1)”，请将“获取最高-最低温度报告”替换为“获取 thermostat1 状态报告”。
对于“getMaxMinReport (thermostat2)”，请将“获取最高-最低温度报告”替换为“获取 thermostat2 状态报告”。
选择“保存”。
若要自定义“目标温度”可写属性在 IoT Central 应用程序中的显示方式：
导航到“设备模板”页面上的“温度控制器”设备模板。
对于“targetTemperature (thermostat1)”，请将“目标温度”替换为“目标温度 (1)”。
对于“targetTemperature (thermostat2)”，请将“目标温度”替换为“目标温度 (2)”。
选择“保存”。
“温度控制器”模型中的恒温器组件包含“目标温度”可写属性，设备模板包含“客户名称”云属性。 操作员可以使用“创建视图”来编辑以下属性：
选择“视图”，然后选择“编辑设备和云数据”磁贴。
输入“属性”作为窗体名称。
选择“目标温度(1)”、“目标温度(2)”和“客户名称”属性。 然后选择“添加部分”。
保存所做更改。
发布设备模板
必须先发布设备模板，操作员才能查看和使用你进行的自定义。
从“恒温器”设备模板中，选择“发布”。 在“将此设备模板发布到应用程序”面板中，选择“发布”。
操作员现在可以使用“属性”视图来更新属性值，并在设备命令页上调用“获取恒温器 1 状态报告”和“获取恒温器 2 状态报告”的命令：
更新“属性”页上的可写属性值：
从“命令”页中调用命令。 如果运行状态报告命令，请在运行该命令之前为参数“自”选择一个日期和时间：
可以看到设备如何对命令和属性更新做出响应：
{'thermostat1': {'targetTemperature': 67, '__t': 'c'}, '$version': 2}
the data in the desired properties patch was: {'thermostat1': {'targetTemperature': 67, '__t': 'c'}, '$version': 2}
Values received are :-
{'targetTemperature': 67, '__t': 'c'}
Sent message
...
Command request received with payload
2021-03-31T05:00:00.000Z
Will return the max, min and average temperature from the specified time 2021-03-31T05:00:00.000Z to the current time
Done generating
{"avgTemp": 4.0, "endTime": "2021-03-31T12:29:48.322427", "maxTemp": 18, "minTemp": null, "startTime": "2021-03-31T12:28:28.322381"}
查看原始数据
你可以使用“原始数据”视图检查设备发送到 IoT Central 的原始数据：
在此视图中，你可以选择要显示的列，并设置要查看的时间范围。 “未建模数据”列显示与设备模板中的任何属性或遥测定义不匹配的设备数据。
清理资源
如果不打算完成更多 IoT Central 快速入门或教程，则可删除 IoT Central 应用程序：
- 在 IoT Central 应用程序中，导航到“应用程序”“管理”。
- 选择“删除”，然后确认操作。
后续步骤
若要继续浏览 IoT Central 系列教程并详细了解如何构建 IoT Central 解决方案，请参阅：