Tutorial: Interagir com um dispositivo IoT Plug and Play conectado à sua solução

Artigo
02/06/2024

O IoT Plug and Play simplifica a IoT, permitindo que você interaja com as funcionalidades de um dispositivo sem conhecer a implementação do dispositivo subjacente. Este tutorial mostra como usar o C# para se conectar a um dispositivo IoT Plug and Play conectado à sua solução e controlá-lo.

Pré-requisitos

Antes de continuar, não deixe de configurar seu ambiente, incluindo o hub IoT.

Você pode executar este tutorial no Linux ou no Windows. Os comandos do shell neste tutorial seguem a convenção do Linux para os separadores de caminho '/', se você está acompanhando no Windows, não deixe de trocar esses separadores por '\'.

O SDK do .NET mais recente para sua plataforma.
Git.

Clonar o repositório do SDK com o código de exemplo

Se você concluiu o Tutorial: Conectar um aplicativo de exemplo de dispositivo do IoT Plug and Play em execução no Windows ao Hub IoT (C#), você já clonou o repositório.

Clone os exemplos do SDK da IoT do Azure para o repositório GitHub em C#. Abra um prompt de comando em uma pasta de sua escolha. Execute o seguinte comando para clonar o repositório do GitHub do SDK da IoT do Microsoft Azure para .NET:

git clone https://github.com/Azure/azure-iot-sdk-csharp.git

Compilar o código do dispositivo

Agora você pode compilar o exemplo do dispositivo e executá-la. Execute os seguintes comandos para criar o exemplo:

cd azure-iot-sdk-csharp/iothub/device/samples/solutions/PnpDeviceSamples/Thermostat
dotnet build

Executar o exemplo de dispositivo

Para executar a amostra, execute o seguinte comando:

dotnet run

Agora, o dispositivo está pronto para receber comandos e atualizações de propriedade e começou a enviar dados telemétricos para o hub. Mantenha o exemplo em execução enquanto você conclui as próximas etapas.

Executar a solução de exemplo

Em Configurar o ambiente para os inícios rápidos e os tutoriais do IoT Plug and Play, você criou duas variáveis de ambiente para configurar o exemplo a ser conectado ao hub IoT:

IOTHUB_CONNECTION_STRING: a cadeia de conexão do hub IoT anotada anteriormente.
IOTHUB_DEVICE_ID: "my-pnp-device".

Neste tutorial, você usa uma solução de IoT de exemplo escrita em C# para interagir com o dispositivo de exemplo que acabou de configurar e executar.

Em outra janela terminal, navegue até a pasta azure-iot-sdk-csharp/iothub/service/samples/solutions/PnpServiceSamples/Thermostat.
Execute o seguinte comando para compilar o exemplo do serviço:
```
dotnet build
```
Execute o seguinte comando para executar o exemplo do serviço:
```
dotnet run
```

Obter dispositivo gêmeo

O seguinte snippet de código mostra como o aplicativo de serviço recupera o dispositivo gêmeo:

// Get a Twin and retrieves model Id set by Device client
Twin twin = await s_registryManager.GetTwinAsync(s_deviceId);
s_logger.LogDebug($"Model Id of this Twin is: {twin.ModelId}");

Observação

Este exemplo usa o namespace Microsoft.Azure.Devices.Client do cliente do serviço Hub IoT. Para saber mais sobre as APIs, incluindo a API de gêmeos digitais, confira o guia de desenvolvedor do serviço.

Esse código gera a seguinte saída:

[09/21/2020 11:26:04]dbug: Thermostat.Program[0]
      Model Id of this Twin is: dtmi:com:example:Thermostat;1

O seguinte snippet de código mostra como usar um patch para atualizar as propriedades por meio do dispositivo gêmeo:

// Update the twin
var twinPatch = new Twin();
twinPatch.Properties.Desired[PropertyName] = PropertyValue;
await s_registryManager.UpdateTwinAsync(s_deviceId, twinPatch, twin.ETag);

Este código gera a seguinte saída do dispositivo quando o serviço atualiza a propriedade targetTemperature:

[09/21/2020 11:26:05]dbug: Thermostat.ThermostatSample[0]
      Property: Received - { "targetTemperature": 60°C }.
[09/21/2020 11:26:05]dbug: Thermostat.ThermostatSample[0]
      Property: Update - {"targetTemperature": 60°C } is InProgress.

...

[09/21/2020 11:26:17]dbug: Thermostat.ThermostatSample[0]
      Property: Update - {"targetTemperature": 60°C } is Completed.

Invocar um comando

O seguinte snippet de código mostra como chamar um comando:

private static async Task InvokeCommandAsync()
{
    var commandInvocation = new CloudToDeviceMethod(CommandName) { ResponseTimeout = TimeSpan.FromSeconds(30) };

    // Set command payload
    string componentCommandPayload = JsonConvert.SerializeObject(s_dateTime);
    commandInvocation.SetPayloadJson(componentCommandPayload);

    CloudToDeviceMethodResult result = await s_serviceClient.InvokeDeviceMethodAsync(s_deviceId, commandInvocation);

    if (result == null)
    {
        throw new Exception($"Command {CommandName} invocation returned null");
    }

    s_logger.LogDebug($"Command {CommandName} invocation result status is: {result.Status}");
}

Este código gera a seguinte saída do dispositivo quando o serviço chama o comando getMaxMinReport:

[09/21/2020 11:26:05]dbug: Thermostat.ThermostatSample[0]
      Command: Received - Generating max, min and avg temperature report since 21/09/2020 11:25:58.
[09/21/2020 11:26:05]dbug: Thermostat.ThermostatSample[0]
      Command: MaxMinReport since 21/09/2020 11:25:58: maxTemp=32, minTemp=32, avgTemp=32, startTime=21/09/2020 11:25:59, endTime=21/09/2020 11:26:04

O IoT Plug and Play simplifica a IoT, permitindo que você interaja com as funcionalidades de um dispositivo sem conhecer a implementação do dispositivo subjacente. Este tutorial mostra como usar o Java para se conectar a um dispositivo IoT Plug and Play conectado à sua solução e controlá-lo.

Pré-requisitos

Antes de continuar, não deixe de configurar seu ambiente, incluindo o hub IoT.

Para concluir este tutorial, instale o seguinte software em seu ambiente de desenvolvimento local:

Clonar o repositório do SDK com o código de exemplo

Se você concluiu o Tutorial: Conectar um aplicativo de exemplo de dispositivo do IoT Plug and Play em execução no Windows ao Hub IoT (Java), você já clonou o repositório.

Abra um prompt de comando no diretório de sua escolha. Execute o seguinte comando para clonar o repositório do GitHub SDK de IoT do Microsoft Azure para Java nesta localização:

git clone https://github.com/Azure/azure-iot-sdk-java.git

Compilar e executar o dispositivo de exemplo

Navegue até a pasta raiz do exemplo de termostato no repositório do SDK do Java clonado e compile-o:

cd azure-iot-sdk-java/device/iot-device-samples/pnp-device-sample/thermostat-device-sample
mvn clean package

Em Configurar um ambiente, você criou quatro variáveis de ambiente para configurar o exemplo e usar o DPS (Serviço de Provisionamento de Dispositivos) para conectar-se ao hub IoT:

IOTHUB_DEVICE_SECURITY_TYPE com o valor DPS
IOTHUB_DEVICE_DPS_ID_SCOPE com a ID de escopo do DPS.
IOTHUB_DEVICE_DPS_DEVICE_ID com o valor my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY com a chave primária de registro.
IOTHUB_DEVICE_DPS_ENDPOINT com o valor global.azure-devices-provisioning.net.

Para saber mais sobre a configuração do exemplo, confira o leiame de exemplo.

Na pasta /device/iot-device-samples/pnp-device-sample/thermostat-device-sample, execute o aplicativo:

mvn exec:java -Dexec.mainClass="samples.com.microsoft.azure.sdk.iot.device.Thermostat"

Executar a solução de exemplo

Em Configurar o ambiente para os inícios rápidos e os tutoriais do IoT Plug and Play, você criou duas variáveis de ambiente para configurar o exemplo a ser conectado ao hub IoT:

IOTHUB_CONNECTION_STRING: a cadeia de conexão do hub IoT anotada anteriormente.
IOTHUB_DEVICE_ID: "my-pnp-device".

Neste tutorial, você usa uma solução de IoT de exemplo escrita em Java para interagir com o dispositivo de exemplo que acabou de configurar.

Observação

Este exemplo usa o namespace com.microsoft.azure.sdk.iot.service do cliente do serviço do Hub IoT. Para saber mais sobre as APIs, incluindo a API de gêmeos digitais, confira o guia do desenvolvedor do serviço.

Abra outra janela de terminal para usar como o seu terminal de serviço.
No repositório do SDK do Java clonado, navegue até a pasta service/iot-service-samples/pnp-service-sample/thermostat-service-sample.

Para compilar e executar o aplicativo de serviço de exemplo, execute o seguinte comando:

mvn clean package
mvn exec:java -Dexec.mainClass="samples.com.microsoft.azure.sdk.iot.service.Thermostat"

Obter dispositivo gêmeo

O seguinte snippet de código mostra como recuperar o dispositivo gêmeo no serviço:

 // Get the twin and retrieve model Id set by Device client.
DeviceTwinDevice twin = new DeviceTwinDevice(deviceId);
twinClient.getTwin(twin);
System.out.println("Model Id of this Twin is: " + twin.getModelId());

Atualizar um dispositivo gêmeo

O seguinte snippet de código mostra como usar um patch para atualizar as propriedades por meio do dispositivo gêmeo:

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

A saída do dispositivo mostra como o dispositivo responde a essa atualização de propriedade.

Invocar um comando

O seguinte snippet de código mostra como chamar um comando no dispositivo:

// The method to invoke for a device without components should be "methodName" as defined in the DTDL.
String methodToInvoke = "getMaxMinReport";
System.out.println("Invoking method: " + methodToInvoke);

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

// Invoke the command.
String commandInput = ZonedDateTime.now(ZoneOffset.UTC).minusMinutes(5).format(DateTimeFormatter.ISO_DATE_TIME);
MethodResult result = methodClient.invoke(deviceId, methodToInvoke, responseTimeout, connectTimeout, commandInput);
if(result == null)
{
    throw new IOException("Method result is null");
}

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

A saída do dispositivo mostra como o dispositivo responde a esse comando.

O IoT Plug and Play simplifica a IoT, permitindo que você interaja com as funcionalidades de um dispositivo sem conhecer a implementação do dispositivo subjacente. Este tutorial mostra como usar o Node.js para se conectar a um dispositivo IoT Plug and Play conectado à sua solução e controlá-lo.

Pré-requisitos

Antes de continuar, não deixe de configurar seu ambiente, incluindo o hub IoT.

Para concluir este tutorial, você precisa do Node.js em seu computador de desenvolvimento. Você pode baixar a versão mais recente recomendada para várias plataformas de nodejs.org.

Você pode verificar a versão atual do Node.js no computador de desenvolvimento usando o seguinte comando:

node --version

Clonar o repositório do SDK com o código de exemplo

Clone os exemplos de um repositório do SDK do Node. Abra uma janela de terminal em uma pasta de sua escolha. Execute o seguinte comando para clonar o repositório GitHub do SDK do IoT do Microsoft Azure para Node.js:

git clone https://github.com/Azure/azure-iot-sdk-node

Executar o dispositivo de exemplo

Em Configurar um ambiente, você criou quatro variáveis de ambiente para configurar o exemplo e usar o DPS (Serviço de Provisionamento de Dispositivos) para conectar-se ao hub IoT:

IOTHUB_DEVICE_SECURITY_TYPE com o valor DPS
IOTHUB_DEVICE_DPS_ID_SCOPE com a ID de escopo do DPS.
IOTHUB_DEVICE_DPS_DEVICE_ID com o valor my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY com a chave primária de registro.
IOTHUB_DEVICE_DPS_ENDPOINT com o valor global.azure-devices-provisioning.net.

Para saber mais sobre a configuração do exemplo, confira o leiame de exemplo.

Neste tutorial, você usa um dispositivo de termostato de exemplo que é escrito em Node.js como o dispositivo do IoT Plug and Play. Para executar o dispositivo de exemplo:

Abra uma janela de terminal e navegue até a pasta local que contém o SDK de IoT do Microsoft Azure para o repositório do Node.js clonado do GitHub.
Esta janela de terminal é usada como o seu terminal de dispositivo. Acesse a pasta do repositório clonado e navegue até a pasta /azure-iot-sdk-node/device/samples/javascript. Instale todas as dependências executando o seguinte comando:
```
npm install
```
Execute o dispositivo de termostato de exemplo com o seguinte comando:
```
node pnp_simple_thermostat.js
```
Você vê mensagens dizendo que o dispositivo enviou algumas informações e se reportou online. Essas mensagens indicam que o dispositivo começou a enviar dados telemétricos para o hub e agora está pronto para receber comandos e atualizações de propriedade. Não feche este terminal; você precisará dele para confirmar se a amostra de serviço está funcionando.

Executar a solução de exemplo

Em Configurar o ambiente para os inícios rápidos e os tutoriais do IoT Plug and Play, você criou duas variáveis de ambiente para configurar o exemplo a ser conectado ao hub IoT:

IOTHUB_CONNECTION_STRING: a cadeia de conexão do hub IoT anotada anteriormente.
IOTHUB_DEVICE_ID: "my-pnp-device".

Neste tutorial, você usa uma solução de IoT de exemplo Node.js para interagir com o dispositivo de exemplo que acabou de configurar e executar.

Abra outra janela de terminal para usar como o seu terminal de serviço.
No repositório clonado do SDK do Node, navegue até a pasta azure-iot-sdk-node/service/samples/javascript. Instale todas as dependências executando o seguinte comando:
```
npm install
```

Ler uma propriedade

Quando você executou o dispositivo termostato de exemplo no terminal do dispositivo, você viu as seguintes mensagens indicando seu status online:
```
properties have been reported for component
sending telemetry message 0...
```
Vá para o terminal de serviço e use o seguinte comando para executar a amostra de leitura de informações do dispositivo:
```
node twin.js
```

No saída de terminal do serviço, observe a resposta do dispositivo gêmeo. Você verá a ID do modelo do dispositivo e as propriedades associadas relatadas:

Model Id: dtmi:com:example:Thermostat;1
{
  "deviceId": "my-pnp-device",
  "etag": "AAAAAAAAAAE=",
  "deviceEtag": "Njc3MDMxNDcy",
  "status": "enabled",
  "statusUpdateTime": "0001-01-01T00:00:00Z",
  "connectionState": "Connected",
  "lastActivityTime": "0001-01-01T00:00:00Z",
  "cloudToDeviceMessageCount": 0,
  "authenticationType": "sas",
  "x509Thumbprint": {
    "primaryThumbprint": null,
    "secondaryThumbprint": null
  },
  "modelId": "dtmi:com:example:Thermostat;1",
  "version": 4,
  "properties": {
    "desired": {
      "$metadata": {
        "$lastUpdated": "2020-10-05T11:35:19.4574755Z"
      },
      "$version": 1
    },
    "reported": {
      "maxTempSinceLastReboot": 31.343640523762232,
      "serialNumber": "123abc",
      "$metadata": {
        "$lastUpdated": "2020-10-05T11:35:23.7339042Z",
        "maxTempSinceLastReboot": {
          "$lastUpdated": "2020-10-05T11:35:23.7339042Z"
        },
        "serialNumber": {
          "$lastUpdated": "2020-10-05T11:35:23.7339042Z"
        }
      },
      "$version": 3
    }
  },
  "capabilities": {
    "iotEdge": false
  },
  "tags": {}
}

O seguinte snippet mostra o código em twin.js que recupera a ID do modelo do dispositivo gêmeo:

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

Neste cenário, ele gera Model Id: dtmi:com:example:Thermostat;1.

Observação

Esses exemplos de serviço usam a classe Registry do cliente do serviço do Hub IoT. Para saber mais sobre as APIs, incluindo a API de gêmeos digitais, confira o guia do desenvolvedor do serviço.

Atualizar uma propriedade gravável

Abra o arquivo twin.js em um editor de código.
Examine o código de exemplo; ele mostra duas formas para atualizar o dispositivo gêmeo. Para usar a primeira, modifique a variável twinPatch da seguinte maneira:
```
var twinPatch = {
  tags: {
    city: "Redmond"
  },
  properties: {
    desired: {
      targetTemperature: 42
    }
  }
};
```
A propriedade targetTemperature é definida como uma propriedade gravável no modelo de dispositivo Termostato.
No terminal de serviço, use o seguinte comando para executar a amostra de atualização da propriedade:
```
node twin.js
```

No terminal do dispositivo, você verá que o dispositivo recebeu a atualização:

The following properties will be updated for the default component:
{
  targetTemperature: {
    value: 42,
    ac: 200,
    ad: 'Successfully executed patch for targetTemperature',
    av: 2
  }
}
updated the property

No terminal de serviço, execute o seguinte comando para confirmar se a propriedade está atualizada:
```
node twin.js
```
No saída de terminal de serviço, na seção de propriedadesreported, você verá a temperatura de destino atualizada relatada. Pode demorar algum tempo para que o dispositivo conclua a atualização. Repita essa etapa até que o dispositivo tenha processado a atualização da propriedade:
```
"reported": {
  //...
  "targetTemperature": {
    "value": 42,
    "ac": 200,
    "ad": "Successfully executed patch for targetTemperature",
    "av": 4
  },
  //...
}
```

Invocar um comando

Abra o arquivo device_method.js e examine o código.

Vá para o terminal de serviço. Use o seguinte comando para executar a amostra para invocar o comando:

set IOTHUB_METHOD_NAME=getMaxMinReport
set IOTHUB_METHOD_PAYLOAD=commandpayload
node device_method.js

A saída no terminal de serviço mostra a seguinte confirmação:

getMaxMinReport on my-pnp-device:
{
  "status": 200,
  "payload": {
    "maxTemp": 23.460596940801928,
    "minTemp": 23.460596940801928,
    "avgTemp": 23.460596940801928,
    "endTime": "2020-10-05T12:48:08.562Z",
    "startTime": "2020-10-05T12:47:54.450Z"
  }
}

No terminal do dispositivo, você verá que o comando foi confirmado:

MaxMinReport commandpayload
Response to method 'getMaxMinReport' sent successfully.

O IoT Plug and Play simplifica a IoT ao permitir que você interaja com o modelo de um dispositivo sem conhecer a implementação subjacente dele. Este tutorial mostra como usar o Python para se conectar a um dispositivo IoT Plug and Play conectado à sua solução e controlá-lo.

Pré-requisitos

Antes de continuar, não deixe de configurar seu ambiente, incluindo o hub IoT.

Para concluir este tutorial, você precisará do Python instalado no seu computador de desenvolvimento. Verifique o SDK do Python da Internet das Coisas do Azure, para obter os requisitos atuais de versão do Python. Verifique a sua versão do Python com o seguinte comando:

python --version

Baixe a versão mais recente recomendada para várias plataformas em python.org.

No ambiente Python local, instale o pacote azure-iot-device da seguinte maneira:

pip install azure-iot-device

Instale o pacote azure-iot-hub executando o seguinte comando:

pip install azure-iot-hub

Executar o dispositivo de exemplo

Em Configurar um ambiente, você criou quatro variáveis de ambiente para configurar o exemplo e usar o DPS (Serviço de Provisionamento de Dispositivos) para conectar-se ao hub IoT:

IOTHUB_DEVICE_SECURITY_TYPE com o valor DPS
IOTHUB_DEVICE_DPS_ID_SCOPE com a ID de escopo do DPS.
IOTHUB_DEVICE_DPS_DEVICE_ID com o valor my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY com a chave primária de registro.
IOTHUB_DEVICE_DPS_ENDPOINT com o valor global.azure-devices-provisioning.net.

Para saber mais sobre a configuração do exemplo, confira o leiame de exemplo.

Neste tutorial, você usará um dispositivo de termostato gravado em Python como o dispositivo IoT Plug and Play. Para executar o dispositivo de exemplo:

Abra uma janela de terminal em uma pasta de sua escolha. Execute o seguinte comando para clonar o repositório do GitHub SDK do Python do dispositivo IoT do Azure nesta localização:
```
git clone --branch v2 https://github.com/Azure/azure-iot-sdk-python
```
Esta janela de terminal é usada como o seu terminal de dispositivo. Acesse a pasta do repositório clonado e navegue até a pasta azure-iot-sdk-node/device/samples/pnp.
Execute o dispositivo de termostato de exemplo com o seguinte comando:
```
python simple_thermostat.py
```
Você vê mensagens dizendo que o dispositivo enviou algumas informações e se reportou online. Essas mensagens indicam que o dispositivo começou a enviar dados telemétricos para o hub e agora está pronto para receber comandos e atualizações de propriedade. Não feche este terminal; você precisará dele para confirmar se a amostra de serviço está funcionando.

Executar a solução de exemplo

Neste tutorial, você usará uma solução de IoT de exemplo em Python para interagir com o dispositivo de exemplo que acabou de configurar.

Abra outra janela de terminal para usar como o seu terminal de serviço. Execute o seguinte comando para clonar o repositório do GitHub SDK do Python do Hub IoT do Azure nesta localização:
```
git clone https://github.com/Azure/azure-iot-hub-python
```
Instalar o
Navegue até a pasta /azure-iot-hub-python/samples do repositório clonado do SDK do Python.
Abra o arquivo registry_manager_pnp_sample.py e examine o código. Este exemplo mostra como usar a classe IoTHubRegistryManager para interagir com o dispositivo do IoT Plug and Play.

Observação

Esses exemplos de serviço usam a classe IoTHubRegistryManager do cliente do serviço do Hub IoT. Para saber mais sobre as APIs, incluindo a API de gêmeos digitais, confira o guia do desenvolvedor do serviço.

Obter o dispositivo gêmeo

Em Configurar o ambiente para os inícios rápidos e os tutoriais do IoT Plug and Play, você criou duas variáveis de ambiente para configurar o exemplo a ser conectado ao hub IoT:

IOTHUB_CONNECTION_STRING: a cadeia de conexão do hub IoT anotada anteriormente.
IOTHUB_DEVICE_ID: "my-pnp-device".

Use o seguinte comando no terminal do serviço para executar este exemplo:

set IOTHUB_METHOD_NAME="getMaxMinReport"
set IOTHUB_METHOD_PAYLOAD="hello world"
python registry_manager_pnp_sample.py

Observação

Se você estiver executando esse exemplo no Linux, use export no lugar de set.

A saída mostra o dispositivo gêmeo e imprime a sua ID de modelo:

The Model ID for this device is:
dtmi:com:example:Thermostat;1

O seguinte snippet mostra o código de exemplo de registry_manager_pnp_sample.py:

    # Create IoTHubRegistryManager
    iothub_registry_manager = IoTHubRegistryManager(iothub_connection_str)

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

    # Print the device's model ID
    additional_props = twin.additional_properties
    if "modelId" in additional_props:
        print("The Model ID for this device is:")
        print(additional_props["modelId"])
        print("")

Atualizar um dispositivo gêmeo

Este exemplo mostra como atualizar a propriedade targetTemperature gravável no dispositivo:

    # Update twin
    twin_patch = Twin()
    twin_patch.properties = TwinProperties(
        desired={"targetTemperature": 42}
    )  # this is relevant for the thermostat device sample
    updated_twin = iothub_registry_manager.update_twin(device_id, twin_patch, twin.etag)
    print("The twin patch has been successfully applied")
    print("")

Você pode verificar se a atualização é aplicada no terminal do dispositivo que mostra a saída seguir:

the data in the desired properties patch was: {'targetTemperature': 42, '$version': 2}

O terminal do serviço confirma que o patch foi bem-sucedido:

The twin patch has been successfully applied

Invocar um comando

Em seguida, o exemplo invoca um comando:

O terminal do serviço mostra uma mensagem de confirmação do dispositivo:

The device method has been successfully invoked

No terminal do dispositivo, você vê que o dispositivo recebe o comando:

Command request received with payload
hello world
Will return the max, min and average temperature from the specified time hello to the current time
Done generating
{"tempReport": {"avgTemp": 34.2, "endTime": "09/07/2020 09:58:11", "maxTemp": 49, "minTemp": 10, "startTime": "09/07/2020 09:56:51"}}

Limpar os recursos

Se você tiver concluído os guias de início rápido e os tutoriais, confira Limpar recursos.

Próximas etapas

Neste tutorial, você aprendeu a conectar um dispositivo IoT Plug and Play a uma solução de IoT. Para saber mais sobre os modelos de dispositivos IoT Plug and Play, confira:

Guia do desenvolvedor de modelagem do IoT Plug and Play

Compartilhar via

Tutorial: Interagir com um dispositivo IoT Plug and Play conectado à sua solução

Pré-requisitos

Clonar o repositório do SDK com o código de exemplo

Compilar o código do dispositivo

Executar o exemplo de dispositivo

Executar a solução de exemplo

Obter dispositivo gêmeo

Invocar um comando

Pré-requisitos

Clonar o repositório do SDK com o código de exemplo

Compilar e executar o dispositivo de exemplo

Executar a solução de exemplo

Obter dispositivo gêmeo

Atualizar um dispositivo gêmeo

Invocar um comando

Pré-requisitos

Clonar o repositório do SDK com o código de exemplo

Executar o dispositivo de exemplo

Executar a solução de exemplo

Ler uma propriedade

Atualizar uma propriedade gravável

Invocar um comando

Pré-requisitos

Executar o dispositivo de exemplo

Executar a solução de exemplo

Obter o dispositivo gêmeo

Atualizar um dispositivo gêmeo

Invocar um comando

Limpar os recursos

Próximas etapas

Comentários

Recursos adicionais