Esercitazione: Interagire con un dispositivo Plug and Play IoT connesso alla soluzione

Articolo
02/06/2024

Plug and Play IoT semplifica l'Internet delle cose consentendo di interagire con le funzionalità di un dispositivo senza conoscere l'implementazione del dispositivo sottostante. Questa esercitazione illustra come usare C# per connettersi e controllare un dispositivo Plug and Play IoT connesso alla soluzione.

Prerequisiti

Prima di continuare, assicurarsi di aver configurato l'ambiente, incluso l'hub IoT.

È possibile eseguire questa esercitazione in Linux o in Windows. I comandi della shell in questa esercitazione seguono la convenzione Linux per i separatori di percorso '/'. Se si usa Windows, assicurarsi di sostituire questi separatori con '\'.

La versione più recente di .NET SDK per la piattaforma.
Git.

Clonare il repository dell'SDK con il codice di esempio

Se è stata completata l'esercitazione: Connessione un'applicazione del dispositivo di esempio Plug and Play IoT in esecuzione in Windows per hub IoT (C#), il repository è già stato clonato.

Clonare gli esempi dal repository GitHub azure IoT SDK per C#. Aprire un prompt dei comandi in una cartella di propria scelta. Eseguire il comando seguente per clonare il repository GitHub di Microsoft Azure IoT SDK per .NET :

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

Compilare il codice del dispositivo

È ora possibile compilare l'esempio di dispositivo ed eseguirlo. Eseguire i comandi seguenti per compilare l'esempio:

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

Eseguire l'esempio del dispositivo

Per eseguire l'esempio, eseguire il comando seguente:

dotnet run

Il dispositivo è ora pronto a ricevere comandi e aggiornamenti delle proprietà e ha iniziato a inviare dati di telemetria all'hub. Lasciare l'esempio in esecuzione mentre si completano i passaggi successivi.

Eseguire la soluzione di esempio

In Configurare l'ambiente per le guide introduttive e le esercitazioni Plug and Play IoT sono state create due variabili di ambiente per configurare l'esempio per la connessione all'hub IoT:

IOTHUB_CONNECTION_STRING: stringa di connessione dell'hub IoT annotata in precedenza.
IOTHUB_DEVICE_ID: "my-pnp-device".

In questa esercitazione si usa una soluzione IoT di esempio scritta in C# per interagire con il dispositivo di esempio appena configurato ed eseguito.

In un'altra finestra del terminale passare alla cartella azure-iot-sdk-csharp/iothub/service/samples/solutions/PnpServiceSamples/Thermostat .
Eseguire il comando seguente per compilare l'esempio di servizio:
```
dotnet build
```
Eseguire il comando seguente per eseguire l'esempio di servizio:
```
dotnet run
```

Recuperare il dispositivo gemello

Il frammento di codice seguente mostra come l'applicazione del servizio recupera il dispositivo gemello:

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

Nota

In questo esempio viene usato lo spazio dei nomi Microsoft.Azure.Devices.Client dal client del servizio hub IoT. Per altre informazioni sulle API, tra cui l'API gemelli digitali, vedere la guida per sviluppatori di servizi.

Questo codice genera l'output seguente:

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

Questo frammento di codice mostra come usare una patch per aggiornare le proprietà tramite il dispositivo gemello:

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

Questo codice genera l'output seguente dal dispositivo quando il servizio aggiorna la proprietà 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.

Richiamare un comando

Il frammento di codice seguente mostra come chiamare un 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}");
}

Questo codice genera l'output seguente dal dispositivo quando il servizio chiama il 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

Plug and Play IoT semplifica l'Internet delle cose consentendo di interagire con le funzionalità di un dispositivo senza conoscere l'implementazione del dispositivo sottostante. Questa esercitazione illustra come usare Java per connettersi e controllare un dispositivo Plug and Play IoT connesso alla soluzione.

Prerequisiti

Prima di continuare, assicurarsi di aver configurato l'ambiente, incluso l'hub IoT.

Per completare questa esercitazione, installare il software seguente nell'ambiente di sviluppo locale:

Clonare il repository dell'SDK con il codice di esempio

Se è stata completata l'esercitazione: Connessione un'applicazione del dispositivo di esempio Plug and Play IoT in esecuzione in Windows per hub IoT (Java), il repository è già stato clonato.

Aprire un prompt dei comandi nella directory di propria scelta. Eseguire questo comando per clonare il repository GitHub Microsoft Azure IoT SDK per Java in questo percorso:

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

Compilare ed eseguire il dispositivo di esempio

Passare alla cartella radice dell'esempio di termostato nel repository Java SDK clonato e compilarla:

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

Nell'articolo Configurare l'ambiente sono state create quattro variabili di ambiente per configurare l'esempio in modo da usare il servizio Device Provisioning per connettersi all'hub IoT:

IOTHUB_DEVICE_SECURITY_TYPE con il valore DPS
IOTHUB_DEVICE_DPS_ID_SCOPE con l'ambito ID servizio Device Provisioning.
IOTHUB_DEVICE_DPS_DEVICE_ID con il valore my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY con la chiave primaria di registrazione.
IOTHUB_DEVICE_DPS_ENDPOINT con il valore global.azure-devices-provisioning.net.

Per altre informazioni sulla configurazione di esempio, vedere il file Leggimi dell'esempio.

Dalla cartella /device/iot-device-samples/pnp-device-sample/thermostat-device-sample eseguire l'applicazione:

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

Eseguire la soluzione di esempio

In Configurare l'ambiente per le guide introduttive e le esercitazioni Plug and Play IoT sono state create due variabili di ambiente per configurare l'esempio per la connessione all'hub IoT:

IOTHUB_CONNECTION_STRING: stringa di connessione dell'hub IoT annotata in precedenza.
IOTHUB_DEVICE_ID: "my-pnp-device".

In questa esercitazione si usa una soluzione IoT di esempio scritta in Java per interagire con il dispositivo di esempio appena configurato.

Nota

In questo esempio viene usato lo spazio dei nomi com.microsoft.azure.sdk.iot.service dal client del servizio hub IoT. Per altre informazioni sulle API, tra cui l'API gemelli digitali, vedere la guida per sviluppatori di servizi.

Aprire un'altra finestra terminale da usare come terminale del servizio.
Nel repository Java SDK clonato passare alla cartella service/iot-service-samples/pnp-service-sample/thermostat-service-sample .

Per compilare ed eseguire l'applicazione di servizio di esempio, eseguire i comandi seguenti:

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

Recuperare il dispositivo gemello

Il frammento di codice seguente mostra come recuperare il dispositivo gemello nel servizio:

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

Aggiornare un dispositivo gemello

Questo frammento di codice mostra come usare una patch per aggiornare le proprietà tramite il dispositivo gemello:

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

L'output del dispositivo mostra il modo in cui il dispositivo risponde all'aggiornamento della proprietà.

Richiamare un comando

Il frammento di codice seguente mostra come chiamare un comando sul 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());

L'output del dispositivo mostra il modo in cui il dispositivo risponde a questo comando.

Plug and Play IoT semplifica l'Internet delle cose consentendo di interagire con le funzionalità di un dispositivo senza conoscere l'implementazione del dispositivo sottostante. Questa esercitazione illustra come usare Node.js per connettersi e controllare un dispositivo Plug and Play IoT connesso alla soluzione.

Prerequisiti

Prima di continuare, assicurarsi di aver configurato l'ambiente, incluso l'hub IoT.

Per completare questa esercitazione, è necessario Node.js nel computer di sviluppo. È possibile scaricare la versione più recente consigliata per più piattaforme da nodejs.org.

È possibile verificare la versione corrente di Node.js installata nel computer di sviluppo tramite il comando seguente:

node --version

Clonare il repository dell'SDK con il codice di esempio

Clonare gli esempi dal repository dell'SDK per Node. Aprire una finestra del terminale in una cartella di propria scelta. Eseguire questo comando per clonare il repository GitHub di Microsoft Azure IoT SDK per Node.js:

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

Eseguire il dispositivo di esempio

Nell'articolo Configurare l'ambiente sono state create quattro variabili di ambiente per configurare l'esempio in modo da usare il servizio Device Provisioning per connettersi all'hub IoT:

IOTHUB_DEVICE_SECURITY_TYPE con il valore DPS
IOTHUB_DEVICE_DPS_ID_SCOPE con l'ambito ID servizio Device Provisioning.
IOTHUB_DEVICE_DPS_DEVICE_ID con il valore my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY con la chiave primaria di registrazione.
IOTHUB_DEVICE_DPS_ENDPOINT con il valore global.azure-devices-provisioning.net.

Per altre informazioni sulla configurazione di esempio, vedere il file Leggimi dell'esempio.

In questa esercitazione si usa un dispositivo termostato di esempio scritto in Node.js come dispositivo Plug and Play IoT. Per eseguire il dispositivo di esempio:

Aprire una finestra del terminale e passare alla cartella locale che contiene il repository Microsoft Azure IoT SDK per Node.js clonato da GitHub.
Questa finestra terminale viene ora usata come terminale del dispositivo. Passare alla cartella del repository clonato e passare alla cartella /azure-iot-sdk-node/device/samples/javascript . Installare tutte le dipendenze eseguendo il comando seguente:
```
npm install
```
Eseguire il dispositivo termostato di esempio con il comando seguente:
```
node pnp_simple_thermostat.js
```
Verranno visualizzati messaggi che indicano che il dispositivo ha inviato informazioni e segnalato il proprio stato online. Questi messaggi indicano che il dispositivo ha iniziato a inviare dati di telemetria all'hub ed è ora pronto a ricevere comandi e aggiornamenti delle proprietà. Non chiudere questo terminale perché sarà necessario per verificare il funzionamento del servizio di esempio.

Eseguire la soluzione di esempio

In Configurare l'ambiente per le guide introduttive e le esercitazioni Plug and Play IoT sono state create due variabili di ambiente per configurare l'esempio per la connessione all'hub IoT:

IOTHUB_CONNECTION_STRING: stringa di connessione dell'hub IoT annotata in precedenza.
IOTHUB_DEVICE_ID: "my-pnp-device".

In questa esercitazione si usa un esempio Node.js soluzione IoT per interagire con il dispositivo di esempio appena configurato ed eseguito.

Aprire un'altra finestra terminale da usare come terminale del servizio.
Nel repository node SDK clonato passare alla cartella azure-iot-sdk-node/service/samples/javascript . Installare tutte le dipendenze eseguendo il comando seguente:
```
npm install
```

Leggere una proprietà

Quando è stato eseguito il dispositivo termostato di esempio nel terminale del dispositivo, sono stati visualizzati i messaggi seguenti che ne indicano lo stato online:
```
properties have been reported for component
sending telemetry message 0...
```
Passare al terminale del servizio e usare questo comando per eseguire l'esempio per la lettura delle informazioni sul dispositivo:
```
node twin.js
```

Nell'output del terminale del servizio verificare la risposta del dispositivo gemello. Verificare l'ID modello del dispositivo e le proprietà associate segnalate:

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

Il frammento di codice seguente mostra il codice in twin.js che recupera l'ID modello del dispositivo gemello:

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

In questo scenario restituisce come output Model Id: dtmi:com:example:Thermostat;1.

Nota

Questi esempi di servizio usano la classe Registry del client del servizio hub IoT. Per altre informazioni sulle API, tra cui l'API gemelli digitali, vedere la guida per sviluppatori di servizi.

Aggiornare una proprietà scrivibile

Aprire il file twin.js in un editor di codice.
Esaminare il codice di esempio, in cui vengono illustrati due modi per aggiornare il dispositivo gemello. Per usare il primo modo, modificare la variabile twinPatch come indicato di seguito:
```
var twinPatch = {
  tags: {
    city: "Redmond"
  },
  properties: {
    desired: {
      targetTemperature: 42
    }
  }
};
```
La proprietà targetTemperature è definita come proprietà scrivibile nel modello di dispositivo termostato.
Nel terminale del servizio usare questo comando per eseguire l'esempio per l'aggiornamento della proprietà:
```
node twin.js
```

Nel terminale del dispositivo verificare che il dispositivo abbia ricevuto l'aggiornamento:

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

Nel terminale del servizio eseguire questo comando per confermare che la proprietà è stata aggiornata:
```
node twin.js
```
Nell'output del terminale del servizio, nella sezione delle proprietà reported, verrà visualizzata la temperatura di destinazione aggiornata segnalata. L'aggiornamento del dispositivo potrebbe richiedere tempo. Ripetere questo passaggio fino a quando il dispositivo non ha elaborato l'aggiornamento della proprietà:
```
"reported": {
  //...
  "targetTemperature": {
    "value": 42,
    "ac": 200,
    "ad": "Successfully executed patch for targetTemperature",
    "av": 4
  },
  //...
}
```

Richiamare un comando

Aprire il file device_method.js ed esaminare il codice.
Passare al terminale del servizio. Usare questo comando per eseguire l'esempio per la chiamata del comando:
```
set IOTHUB_METHOD_NAME=getMaxMinReport
set IOTHUB_METHOD_PAYLOAD=commandpayload
node device_method.js
```

L'output nel terminale del servizio mostra la conferma seguente:

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

Nel terminale del dispositivo verificare che il comando sia stato riconosciuto:

MaxMinReport commandpayload
Response to method 'getMaxMinReport' sent successfully.

Plug and Play IoT semplifica l'Internet delle cose consentendo di interagire con il modello di un dispositivo senza conoscere l'implementazione del dispositivo sottostante. Questa esercitazione illustra come usare Python per connettersi e controllare un dispositivo Plug and Play IoT connesso alla soluzione.

Prerequisiti

Prima di continuare, assicurarsi di aver configurato l'ambiente, incluso l'hub IoT.

Per completare questa esercitazione, è necessario che Python sia installato nel computer di sviluppo. Controllare Azure IoT Python SDK per i requisiti correnti per la versione di Python. È possibile controllare la versione di Python con il comando seguente:

python --version

È possibile scaricare la versione più recente consigliata per più piattaforme da python.org.

Nell'ambiente Python locale installare il pacchetto azure-iot-device come indicato di seguito:

pip install azure-iot-device

Installare il pacchetto azure-iot-hub eseguendo questo comando:

pip install azure-iot-hub

Eseguire il dispositivo di esempio

Nell'articolo Configurare l'ambiente sono state create quattro variabili di ambiente per configurare l'esempio in modo da usare il servizio Device Provisioning per connettersi all'hub IoT:

IOTHUB_DEVICE_SECURITY_TYPE con il valore DPS
IOTHUB_DEVICE_DPS_ID_SCOPE con l'ambito ID servizio Device Provisioning.
IOTHUB_DEVICE_DPS_DEVICE_ID con il valore my-pnp-device.
IOTHUB_DEVICE_DPS_DEVICE_KEY con la chiave primaria di registrazione.
IOTHUB_DEVICE_DPS_ENDPOINT con il valore global.azure-devices-provisioning.net.

Per altre informazioni sulla configurazione di esempio, vedere il file Leggimi dell'esempio.

In questa esercitazione si usa un dispositivo termostato di esempio, scritto in Python, come dispositivo Plug and Play IoT. Per eseguire il dispositivo di esempio:

Aprire una finestra del terminale in una cartella di propria scelta. Eseguire il comando seguente per clonare il repository GitHub azure IoT Device Python SDK in questo percorso:
```
git clone --branch v2 https://github.com/Azure/azure-iot-sdk-python
```
Questa finestra terminale viene ora usata come terminale del dispositivo. Passare alla cartella del repository clonato e passare alla cartella azure-iot-sdk-python/samples/pnp .
Eseguire il dispositivo termostato di esempio con il comando seguente:
```
python simple_thermostat.py
```
Verranno visualizzati messaggi che indicano che il dispositivo ha inviato informazioni e segnalato il proprio stato online. Questi messaggi indicano che il dispositivo ha iniziato a inviare dati di telemetria all'hub ed è ora pronto a ricevere comandi e aggiornamenti delle proprietà. Non chiudere questo terminale perché sarà necessario per verificare il funzionamento del servizio di esempio.

Eseguire la soluzione di esempio

In questa esercitazione si usa una soluzione IoT di esempio in Python per interagire con il dispositivo di esempio appena configurato.

Aprire un'altra finestra terminale da usare come terminale del servizio. Eseguire il comando seguente per clonare il repository GitHub hub IoT di Azure Python SDK in questo percorso:
```
git clone https://github.com/Azure/azure-iot-hub-python
```
Installare
Passare alla cartella /azure-iot-hub-python/samples del repository python SDK clonato.
Aprire il file registry_manager_pnp_sample.py ed esaminare il codice. Questo esempio illustra come usare la classe IoTHubRegistryManager per interagire con il dispositivo Plug and Play IoT.

Nota

Questi esempi di servizio usano la classe IoTHubRegistryManager del client del servizio hub IoT. Per altre informazioni sulle API, tra cui l'API gemelli digitali, vedere la guida per sviluppatori di servizi.

Ottenere il dispositivo gemello

In Configurare l'ambiente per le guide introduttive e le esercitazioni Plug and Play IoT sono state create due variabili di ambiente per configurare l'esempio per la connessione all'hub IoT:

IOTHUB_CONNECTION_STRING: stringa di connessione dell'hub IoT annotata in precedenza.
IOTHUB_DEVICE_ID: "my-pnp-device".

Per eseguire l'esempio, usare il comando seguente nel terminale del servizio:

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

Nota

Se si esegue questo esempio in Linux, usare export al posto di set.

L'output mostra il dispositivo gemello e stampa l'ID modello:

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

Il frammento di codice seguente mostra il codice di esempio di 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("")

Aggiornare un dispositivo gemello

Questo esempio illustra come aggiornare la proprietà targetTemperature scrivibile nel 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("")

È possibile verificare l'applicazione dell'aggiornamento nel terminale del dispositivo che mostra l'output seguente:

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

Il terminale del servizio conferma che la patch è stata completata correttamente:

The twin patch has been successfully applied

Richiamare un comando

L'esempio richiama quindi un comando:

Il terminale del servizio mostra un messaggio di conferma dal dispositivo:

The device method has been successfully invoked

Nel terminale del dispositivo è possibile osservare che il dispositivo riceve il 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"}}

Pulire le risorse

Se sono state completate le guide introduttive e le esercitazioni, vedere Pulire le risorse.

Passaggi successivi

In questa esercitazione si è appreso come connettere un dispositivo Plug and Play IoT a una soluzione IoT. Per altre informazioni sui modelli di dispositivo Plug and Play IoT, vedere:

Guida per sviluppatori alla modellazione di Plug and Play IoT

Esercitazione: Interagire con un dispositivo Plug and Play IoT connesso alla soluzione

Prerequisiti

Clonare il repository dell'SDK con il codice di esempio

Compilare il codice del dispositivo

Eseguire l'esempio del dispositivo

Eseguire la soluzione di esempio

Recuperare il dispositivo gemello

Richiamare un comando

Prerequisiti

Clonare il repository dell'SDK con il codice di esempio

Compilare ed eseguire il dispositivo di esempio

Eseguire la soluzione di esempio

Recuperare il dispositivo gemello

Aggiornare un dispositivo gemello

Richiamare un comando

Prerequisiti

Clonare il repository dell'SDK con il codice di esempio

Eseguire il dispositivo di esempio

Eseguire la soluzione di esempio

Leggere una proprietà

Aggiornare una proprietà scrivibile

Richiamare un comando

Prerequisiti

Eseguire il dispositivo di esempio

Eseguire la soluzione di esempio

Ottenere il dispositivo gemello

Aggiornare un dispositivo gemello

Richiamare un comando

Pulire le risorse

Passaggi successivi

Risorse aggiuntive