Condividi tramite

Esercitazione: Connettere un Plug and Play IoT più applicazioni per dispositivi componenti in esecuzione in Linux o Windows a hub IoT

  • Articolo

Questa esercitazione illustra come creare un'applicazione di un dispositivo Plug and Play IoT di esempio con componenti, connetterla all'hub IoT e usare lo strumento Azure IoT Explorer per visualizzare le informazioni inviate all'hub. L'applicazione di esempio è scritta in C ed è inclusa in Azure IoT SDK per dispositivi per C. Un generatore di soluzioni può usare lo strumento Azure IoT Explorer per conoscere le funzionalità di un dispositivo Plug and Play IoT senza dover visualizzare il codice del dispositivo.

Esplora il codice

In questa esercitazione:

  • Scaricare il codice di esempio.
  • Compilare il codice di esempio.
  • Eseguire l'applicazione del dispositivo di esempio e verificare che si connetta all'hub IoT.
  • Esaminare il codice sorgente.

Prerequisiti

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

È possibile completare questa esercitazione in Linux o 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 '\'.

I prerequisiti variano in base al sistema operativo:

Linux

Questa esercitazione presuppone l'uso di Ubuntu Linux. I passaggi in questa esercitazione sono stati testati con Ubuntu 18.04.

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

Installare GCC, Git, cmake e tutte le dipendenze necessarie usando il comando apt-get:

sudo apt-get update
sudo apt-get install -y git cmake build-essential curl libcurl4-openssl-dev libssl-dev uuid-dev

Verificare che la versione di cmake sia superiore alla 2.8.12 e che la versione di GCC sia superiore alla 4.4.7.

cmake --version
gcc --version

Finestre

Per completare questa esercitazione in Windows, installare il software seguente nell'ambiente Windows locale:

Scaricare il codice

Se è stata completata l'esercitazione: Connettere un'applicazione del dispositivo di esempio Plug and Play IoT in esecuzione in Linux o Windows a hub IoT (C) è già stato scaricato il codice.

In questa esercitazione viene preparato un ambiente di sviluppo che è possibile usare per clonare e compilare Azure IoT Hub SDK per dispositivi per C.

Aprire un prompt dei comandi in una cartella di propria scelta. Eseguire questo comando per clonare il repository GitHub di SDK e librerie di Azure IoT per C in tale percorso:

git clone https://github.com/Azure/azure-iot-sdk-c.git
cd azure-iot-sdk-c
git submodule update --init

Il completamento di questa operazione richiederà alcuni minuti.

Compilare ed eseguire il codice

È possibile compilare ed eseguire il codice usando Visual Studio oppure eseguendo cmake dalla riga di comando.

Usare Visual Studio

  1. Aprire la cartella radice del repository clonato. Dopo alcuni secondi, il supporto CMake in Visual Studio crea tutti gli elementi necessari per l'esecuzione e il debug del progetto.

  2. Quando Visual Studio è pronto, in Esplora soluzioni passare alla cartella iothub_client/samples/pnp/pnp_temperature_controller/ di esempio.

  3. Fare clic con il pulsante destro del mouse sul file pnp_temperature_controller.c e selezionare Aggiungi configurazione di debug. Selezionare l'impostazione predefinita.

  4. In Visual Studio viene aperto il file launch.vs.json. Modificare questo file come illustrato nel frammento di codice seguente per impostare le variabili di ambiente richieste. L'ID ambito e la chiave primaria di registrazione sono stati annotati quando sono state completate le guide di avvio rapido e le esercitazioni per configurare l'ambiente per Plug and Play IoT:

    {
  "version": "0.2.1",
  "defaults": {},
  "configurations": [
    {
      "type": "default",
      "project": "iothub_client\\samples\\pnp\\pnp_temperature_controller\\pnp_temperature_controller.c",
      "projectTarget": "",
      "name": "pnp_temperature_controller.c",
      "env": {
        "IOTHUB_DEVICE_SECURITY_TYPE": "DPS",
        "IOTHUB_DEVICE_DPS_ID_SCOPE": "<Your ID scope>",
        "IOTHUB_DEVICE_DPS_DEVICE_ID": "my-pnp-device",
        "IOTHUB_DEVICE_DPS_DEVICE_KEY": "<Your enrollment primary key>"
      }
    }
  ]
}

  5. Fare clic con il pulsante destro del mouse sul file pnp_temperature_controller.c e selezionare Imposta come elemento di avvio.

  6. Per tracciare l'esecuzione del codice in Visual Studio, aggiungere un punto di interruzione alla funzione main nel file pnp_temperature_controller.c.

  7. È ora possibile eseguire l'esempio ed eseguirne il debug dal menu Debug.

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.

Usare cmake dalla riga di comando

Per compilare l'esempio:

  1. Creare una sottocartella cmake nella cartella radice dell'SDK per dispositivi clonato e passare a tale cartella:

    cd azure-iot-sdk-c
mkdir cmake
cd cmake

  2. Eseguire i comandi seguenti per generare e compilare i file di progetto per l'SDK e gli esempi:

    cmake ..
cmake --build .

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.

Per eseguire l'esempio:

  1. Dalla cartella cmake passare alla cartella che contiene il file eseguibile ed eseguirlo:

    # 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

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.

Usare Azure IoT Explorer per convalidare il codice

Dopo l'avvio dell'esempio client del dispositivo, usare lo strumento Azure IoT Explorer per verificarne il funzionamento.

  1. Aprire Azure IoT Explorer.

  2. Nella pagina Hub IoT, se non è già stata aggiunta una connessione all'hub IoT, selezionare + Aggiungi connessione. Immettere la stringa di connessione per l'hub IoT creato in precedenza e selezionare Salva.

  3. Nella pagina Impostazioni Plug and Play IoT selezionare + Aggiungi > cartella locale e selezionare la cartella modelli locale in cui sono stati salvati i file del modello.

  4. Nella pagina Hub IoT fare clic sul nome dell'hub che si vuole usare. Viene visualizzato un elenco dei dispositivi registrati nell'hub IoT.

  5. Fare clic sull'ID dispositivo del dispositivo creato in precedenza.

  6. Il menu a sinistra mostra i diversi tipi di informazioni disponibili per il dispositivo.

  7. Selezionare Componenti Plug and Play IoT per visualizzare le informazioni sul modello del dispositivo.

  8. È possibile visualizzare i diversi componenti del dispositivo. Componente predefinito ed eventuali componenti aggiuntivi. Selezionare un componente da usare.

  9. Selezionare la pagina Telemetria e quindi selezionare Avvia per visualizzare i dati di telemetria inviati dal dispositivo per questo componente.

  10. Selezionare la pagina Proprietà (solo lettura) per visualizzare le proprietà di sola lettura segnalate per questo componente.

  11. Selezionare la pagina Properties (writable) (Proprietà - accessibili in scrittura) per visualizzare le proprietà accessibili in scrittura che è possibile aggiornare per questo componente.

  12. Selezionare una proprietà in base al nome, immettere un nuovo valore e selezionare Update desired value (Aggiorna valore desiderato).

  13. Per visualizzare il nuovo valore, selezionare il pulsante Aggiorna.

  14. Selezionare la pagina Comandi per visualizzare tutti i comandi per questo componente.

  15. Selezionare il comando di cui si vuole testare l'impostazione del parametro, se presente. Selezionare Invia comando per chiamare il comando nel dispositivo. Nella finestra del prompt dei comandi in cui è in esecuzione il codice di esempio si vedrà che il dispositivo risponde al comando.

Esaminare il codice

Questo esempio implementa un dispositivo termoregolatore Plug and Play IoT. In questo esempio viene implementato un modello con più componenti. Il file del modello DTDL (Digital Twins Definition Language) per il dispositivo temperature definisce i dati di telemetria, le proprietà e i comandi implementati dal dispositivo.

Funzioni helper di Plug and Play IoT

Per questo esempio il codice usa alcune funzioni helper della cartella /common:

pnp_device_client_ll contiene il metodo di connessione per Plug and Play IoT con model-id incluso come parametro: PnP_CreateDeviceClientLLHandle.

pnp_protocol contiene le funzioni helper di Plug and Play IoT:

  • PnP_CreateReportedProperty
  • PnP_CreateReportedPropertyWithStatus
  • PnP_ParseCommandName
  • PnP_CreateTelemetryMessageHandle
  • PnP_ProcessTwinData
  • PnP_CopyPayloadToString
  • PnP_CreateDeviceClientLLHandle_ViaDps

Queste funzioni helper sono sufficientemente generiche per essere usate nel progetto. In questo esempio vengono usate nei tre file che corrispondono a ogni componente del modello:

  • pnp_deviceinfo_component
  • pnp_temperature_controller
  • pnp_thermostat_component

Ad esempio, nel file pnp_deviceinfo_component la funzione SendReportedPropertyForDeviceInformation usa due delle funzioni helper:

if ((jsonToSend = PnP_CreateReportedProperty(componentName, propertyName, propertyValue)) == NULL)
{
    LogError("Unable to build reported property response for propertyName=%s, propertyValue=%s", propertyName, propertyValue);
}
else
{
    const char* jsonToSendStr = STRING_c_str(jsonToSend);
    size_t jsonToSendStrLen = strlen(jsonToSendStr);

    if ((iothubClientResult = IoTHubDeviceClient_LL_SendReportedState(deviceClientLL, (const unsigned char*)jsonToSendStr, jsonToSendStrLen, NULL, NULL)) != IOTHUB_CLIENT_OK)
    {
        LogError("Unable to send reported state for property=%s, error=%d", propertyName, iothubClientResult);
    }
    else
    {
        LogInfo("Sending device information property to IoTHub.  propertyName=%s, propertyValue=%s", propertyName, propertyValue);
    }
}

Ogni componente dell'esempio è conforme a questo modello.

flusso del codice

La funzione main inizializza la connessione e invia l'ID modello:

deviceClient = CreateDeviceClientAndAllocateComponents();

Il codice usa PnP_CreateDeviceClientLLHandle per connettersi all'hub IoT, impostare modelId come opzione e configurare i gestori di callback del metodo del dispositivo e del dispositivo gemello per i metodi diretti e gli aggiornamenti del dispositivo gemello:

g_pnpDeviceConfiguration.deviceMethodCallback = PnP_TempControlComponent_DeviceMethodCallback;
g_pnpDeviceConfiguration.deviceTwinCallback = PnP_TempControlComponent_DeviceTwinCallback;
g_pnpDeviceConfiguration.modelId = g_temperatureControllerModelId;
...

deviceClient = PnP_CreateDeviceClientLLHandle(&g_pnpDeviceConfiguration);

&g_pnpDeviceConfiguration contiene anche le informazioni sulla connessione. La variabile di ambiente IOTHUB_DEVICE_SECURITY_TYPE determina se per l'esempio viene usata una stringa di connessione o il servizio di provisioning di dispositivi per connettersi all'hub IoT.

Quando il dispositivo invia un ID modello, diventa un dispositivo Plug and Play IoT.

Se i gestori di callback sono configurati, il dispositivo reagisce agli aggiornamenti del dispositivo gemello e alle chiamate a metodi diretti:

  • Per il callback del dispositivo gemello, PnP_TempControlComponent_DeviceTwinCallback chiama la funzione PnP_ProcessTwinData per elaborare i dati. PnP_ProcessTwinData usa il modello visitor per analizzare il codice JSON e quindi visitare ogni proprietà, chiamando PnP_TempControlComponent_ApplicationPropertyCallback su ogni elemento.

  • Per il callback dei comandi, la funzione PnP_TempControlComponent_DeviceMethodCallback usa la funzione helper per analizzare i nomi di comandi e componenti:

    PnP_ParseCommandName(methodName, &componentName, &componentNameSize, &pnpCommandName);

    La funzione PnP_TempControlComponent_DeviceMethodCallback chiama quindi il comando sul componente:

    LogInfo("Received PnP command for component=%.*s, command=%s", (int)componentNameSize, componentName, pnpCommandName);
if (strncmp((const char*)componentName, g_thermostatComponent1Name, g_thermostatComponent1Size) == 0)
{
    result = PnP_ThermostatComponent_ProcessCommand(g_thermostatHandle1, pnpCommandName, rootValue, response, responseSize);
}
else if (strncmp((const char*)componentName, g_thermostatComponent2Name, g_thermostatComponent2Size) == 0)
{
    result = PnP_ThermostatComponent_ProcessCommand(g_thermostatHandle2, pnpCommandName, rootValue, response, responseSize);
}
else
{
    LogError("PnP component=%.*s is not supported by TemperatureController", (int)componentNameSize, componentName);
    result = PNP_STATUS_NOT_FOUND;
}

La funzione main inizializza le proprietà di sola lettura inviate all'hub IoT:

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

La funzione main immette un ciclo per aggiornare i dati di telemetria e degli eventi per ogni componente:

while (true)
{
    PnP_TempControlComponent_SendWorkingSet(deviceClient);
    PnP_ThermostatComponent_SendTelemetry(g_thermostatHandle1, deviceClient);
    PnP_ThermostatComponent_SendTelemetry(g_thermostatHandle2, deviceClient);
}

La PnP_ThermostatComponent_SendTelemetry funzione mostra come usare lo struct PNP_THERMOSTAT_COMPONENT. Questo struct viene usato nell'esempio per archiviare le informazioni sui due termostati nel dispositivo termoregolatore. Il codice usa la funzione PnP_CreateTelemetryMessageHandle per preparare il messaggio e inviarlo:

messageHandle = PnP_CreateTelemetryMessageHandle(pnpThermostatComponent->componentName, temperatureStringBuffer);
...
iothubResult = IoTHubDeviceClient_LL_SendEventAsync(deviceClientLL, messageHandle, NULL, NULL);

La funzione main, infine, elimina definitivamente i diversi componenti e chiude la connessione all'hub.

Questa esercitazione illustra come creare un'applicazione di un dispositivo Plug and Play IoT di esempio con componenti, connetterla all'hub IoT e usare lo strumento Azure IoT Explorer per visualizzare le informazioni inviate all'hub. L'applicazione di esempio è scritta in C# ed è inclusa in Azure IoT SDK per dispositivi per C#. Un integratore di soluzioni può usare lo strumento Azure IoT Explorer per conoscere le funzionalità di un dispositivo Plug and Play IoT senza doverne visualizzare il codice.

Esplora il codice

In questa esercitazione:

  • Scaricare il codice di esempio.
  • Compilare il codice di esempio.
  • Eseguire l'applicazione del dispositivo di esempio e verificare che si connetta all'hub IoT.
  • Esaminare il codice sorgente.

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 '\'.

Clonare il repository dell'SDK con il codice di esempio

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

Clonare gli esempi dal repository GitHub degli esempi di Azure IoT 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

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

cd azure-iot-sdk-csharp/iothub/device/samples/solutions/PnpDeviceSamples/TemperatureController
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.

Usare Azure IoT Explorer per convalidare il codice

Dopo l'avvio dell'esempio client del dispositivo, usare lo strumento Azure IoT Explorer per verificarne il funzionamento.

  1. Aprire Azure IoT Explorer.

  2. Nella pagina Hub IoT, se non è già stata aggiunta una connessione all'hub IoT, selezionare + Aggiungi connessione. Immettere la stringa di connessione per l'hub IoT creato in precedenza e selezionare Salva.

  3. Nella pagina Impostazioni Plug and Play IoT selezionare + Aggiungi > cartella locale e selezionare la cartella modelli locale in cui sono stati salvati i file del modello.

  4. Nella pagina Hub IoT fare clic sul nome dell'hub che si vuole usare. Viene visualizzato un elenco dei dispositivi registrati nell'hub IoT.

  5. Fare clic sull'ID dispositivo del dispositivo creato in precedenza.

  6. Il menu a sinistra mostra i diversi tipi di informazioni disponibili per il dispositivo.

  7. Selezionare Componenti Plug and Play IoT per visualizzare le informazioni sul modello del dispositivo.

  8. È possibile visualizzare i diversi componenti del dispositivo. Componente predefinito ed eventuali componenti aggiuntivi. Selezionare un componente da usare.

  9. Selezionare la pagina Telemetria e quindi selezionare Avvia per visualizzare i dati di telemetria inviati dal dispositivo per questo componente.

  10. Selezionare la pagina Proprietà (solo lettura) per visualizzare le proprietà di sola lettura segnalate per questo componente.

  11. Selezionare la pagina Properties (writable) (Proprietà - accessibili in scrittura) per visualizzare le proprietà accessibili in scrittura che è possibile aggiornare per questo componente.

  12. Selezionare una proprietà in base al nome, immettere un nuovo valore e selezionare Update desired value (Aggiorna valore desiderato).

  13. Per visualizzare il nuovo valore, selezionare il pulsante Aggiorna.

  14. Selezionare la pagina Comandi per visualizzare tutti i comandi per questo componente.

  15. Selezionare il comando di cui si vuole testare l'impostazione del parametro, se presente. Selezionare Invia comando per chiamare il comando nel dispositivo. Nella finestra del prompt dei comandi in cui è in esecuzione il codice di esempio si vedrà che il dispositivo risponde al comando.

Esaminare il codice

Questo esempio implementa un dispositivo termoregolatore Plug and Play IoT. Il modello implementato da questo esempio usa più componenti. Il file del modello DTDL (Digital Twins Definition Language) per il dispositivo temperature definisce i dati di telemetria, le proprietà e i comandi implementati dal dispositivo.

Il codice del dispositivo si connette all'hub IoT usando il metodo CreateFromConnectionString standard. Il dispositivo invia l'ID modello del modello DTDL implementato nella richiesta di connessione. Un dispositivo che invia un ID modello è un dispositivo Plug and Play IoT:

private static DeviceClient InitializeDeviceClient(string hostname, IAuthenticationMethod authenticationMethod)
{
    var options = new ClientOptions
    {
        ModelId = ModelId,
    };

    var deviceClient = DeviceClient.Create(hostname, authenticationMethod, TransportType.Mqtt, options);
    deviceClient.SetConnectionStatusChangesHandler((status, reason) =>
    {
        s_logger.LogDebug($"Connection status change registered - status={status}, reason={reason}.");
    });

    return deviceClient;
}

L'ID modello viene archiviato nel codice come mostrato nel frammento seguente:

private const string ModelId = "dtmi:com:example:TemperatureController;1";

Quando il dispositivo si connette all'hub IoT, il codice registra i gestori dei comandi. Il comando reboot viene definito nel componente predefinito. Il comando getMaxMinReport viene definito in ognuno dei due componenti del termostato:

await _deviceClient.SetMethodHandlerAsync("reboot", HandleRebootCommandAsync, _deviceClient, cancellationToken);
await _deviceClient.SetMethodHandlerAsync("thermostat1*getMaxMinReport", HandleMaxMinReportCommandAsync, Thermostat1, cancellationToken);
await _deviceClient.SetMethodHandlerAsync("thermostat2*getMaxMinReport", HandleMaxMinReportCommandAsync, Thermostat2, cancellationToken);

Sono disponibili gestori distinti per gli aggiornamenti delle proprietà desiderati sui due componenti del termostato:

_desiredPropertyUpdateCallbacks.Add(Thermostat1, TargetTemperatureUpdateCallbackAsync);
_desiredPropertyUpdateCallbacks.Add(Thermostat2, TargetTemperatureUpdateCallbackAsync);

Il codice di esempio invia dati di telemetria da ogni componente del termostato:

await SendTemperatureAsync(Thermostat1, cancellationToken);
await SendTemperatureAsync(Thermostat2, cancellationToken);

Il metodo SendTemperatureTelemetryAsync usa la classe PnpHelper per creare messaggi per ogni componente:

using Message msg = PnpHelper.CreateIothubMessageUtf8(telemetryName, JsonConvert.SerializeObject(currentTemperature), componentName);

La classe PnpHelper contiene altri metodi di esempio che è possibile usare con un modello a più componenti.

Usare lo strumento Azure IoT Explorer per visualizzare i dati di telemetria e le proprietà dei due componenti del termostato:

Dispositivo a più componenti in Azure IoT Explorer

È anche possibile usare lo strumento Azure IoT Explorer per chiamare i comandi in uno dei due componenti del termostato o nel componente predefinito.

Questa esercitazione illustra come creare un'applicazione di un dispositivo Plug and Play IoT di esempio con componenti, connetterla all'hub IoT e usare lo strumento Azure IoT Explorer per visualizzare le informazioni inviate all'hub. L'applicazione di esempio è scritta in Java ed è inclusa in Azure IoT SDK per dispositivi per Java. Un integratore di soluzioni può usare lo strumento Azure IoT Explorer per conoscere le funzionalità di un dispositivo Plug and Play IoT senza doverne visualizzare il codice.

Esplora il codice

In questa esercitazione:

  • Scaricare il codice di esempio.
  • Compilare il codice di esempio.
  • Eseguire l'applicazione del dispositivo di esempio e verificare che si connetta all'hub IoT.
  • Esaminare il codice sorgente.

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 '\'.

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

Scaricare il codice

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

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

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

Il completamento di questa operazione richiederà alcuni minuti.

Compilare il codice

Passare alla cartella radice dell'esempio del controller di temperatura nel repository java SDK clonato e compilarlo:

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

Eseguire l'esempio del dispositivo

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 eseguire l'applicazione di esempio, passare alla cartella /device/iot-device-samples/pnp-device-sample/temperature-controller-device-sample ed eseguire il comando seguente:

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

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.

Usare Azure IoT Explorer per convalidare il codice

Dopo l'avvio dell'esempio client del dispositivo, usare lo strumento Azure IoT Explorer per verificarne il funzionamento.

  1. Aprire Azure IoT Explorer.

  2. Nella pagina Hub IoT, se non è già stata aggiunta una connessione all'hub IoT, selezionare + Aggiungi connessione. Immettere la stringa di connessione per l'hub IoT creato in precedenza e selezionare Salva.

  3. Nella pagina Impostazioni Plug and Play IoT selezionare + Aggiungi > cartella locale e selezionare la cartella modelli locale in cui sono stati salvati i file del modello.

  4. Nella pagina Hub IoT fare clic sul nome dell'hub che si vuole usare. Viene visualizzato un elenco dei dispositivi registrati nell'hub IoT.

  5. Fare clic sull'ID dispositivo del dispositivo creato in precedenza.

  6. Il menu a sinistra mostra i diversi tipi di informazioni disponibili per il dispositivo.

  7. Selezionare Componenti Plug and Play IoT per visualizzare le informazioni sul modello del dispositivo.

  8. È possibile visualizzare i diversi componenti del dispositivo. Componente predefinito ed eventuali componenti aggiuntivi. Selezionare un componente da usare.

  9. Selezionare la pagina Telemetria e quindi selezionare Avvia per visualizzare i dati di telemetria inviati dal dispositivo per questo componente.

  10. Selezionare la pagina Proprietà (solo lettura) per visualizzare le proprietà di sola lettura segnalate per questo componente.

  11. Selezionare la pagina Properties (writable) (Proprietà - accessibili in scrittura) per visualizzare le proprietà accessibili in scrittura che è possibile aggiornare per questo componente.

  12. Selezionare una proprietà in base al nome, immettere un nuovo valore e selezionare Update desired value (Aggiorna valore desiderato).

  13. Per visualizzare il nuovo valore, selezionare il pulsante Aggiorna.

  14. Selezionare la pagina Comandi per visualizzare tutti i comandi per questo componente.

  15. Selezionare il comando di cui si vuole testare l'impostazione del parametro, se presente. Selezionare Invia comando per chiamare il comando nel dispositivo. Nella finestra del prompt dei comandi in cui è in esecuzione il codice di esempio si vedrà che il dispositivo risponde al comando.

Esaminare il codice

Questo esempio implementa un dispositivo termoregolatore Plug and Play IoT. Il modello implementato da questo esempio usa più componenti. Il file del modello DTDL (Digital Twins Definition Language) per il dispositivo temperature definisce i dati di telemetria, le proprietà e i comandi implementati dal dispositivo.

Il codice del dispositivo usa la classe DeviceClient standard per la connessione all'hub IoT. Il dispositivo invia l'ID modello del modello DTDL implementato nella richiesta di connessione. Un dispositivo che invia un ID modello è un dispositivo Plug and Play IoT:

private static void initializeDeviceClient() throws URISyntaxException, IOException {
    ClientOptions options = new ClientOptions();
    options.setModelId(MODEL_ID);
    deviceClient = new DeviceClient(deviceConnectionString, protocol, options);

    deviceClient.registerConnectionStatusChangeCallback((status, statusChangeReason, throwable, callbackContext) -> {
        log.debug("Connection status change registered: status={}, reason={}", status, statusChangeReason);

        if (throwable != null) {
            log.debug("The connection status change was caused by the following Throwable: {}", throwable.getMessage());
            throwable.printStackTrace();
        }
    }, deviceClient);

    deviceClient.open();
}

L'ID modello viene archiviato nel codice come mostrato nel frammento seguente:

private static final String MODEL_ID = "dtmi:com:example:Thermostat;1";

Quando il dispositivo si connette all'hub IoT, il codice registra i gestori dei comandi.

deviceClient.subscribeToDeviceMethod(new MethodCallback(), null, new MethodIotHubEventCallback(), null);

Sono disponibili gestori distinti per gli aggiornamenti delle proprietà desiderati sui due componenti del termostato:

deviceClient.startDeviceTwin(new TwinIotHubEventCallback(), null, new GenericPropertyUpdateCallback(), null);
Map<Property, Pair<TwinPropertyCallBack, Object>> desiredPropertyUpdateCallback = Stream.of(
        new AbstractMap.SimpleEntry<Property, Pair<TwinPropertyCallBack, Object>>(
                new Property(THERMOSTAT_1, null),
                new Pair<>(new TargetTemperatureUpdateCallback(), THERMOSTAT_1)),
        new AbstractMap.SimpleEntry<Property, Pair<TwinPropertyCallBack, Object>>(
                new Property(THERMOSTAT_2, null),
                new Pair<>(new TargetTemperatureUpdateCallback(), THERMOSTAT_2))
).collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue));

deviceClient.subscribeToTwinDesiredProperties(desiredPropertyUpdateCallback);

Il codice di esempio invia dati di telemetria da ogni componente del termostato:

sendTemperatureReading(THERMOSTAT_1);
sendTemperatureReading(THERMOSTAT_2);

Il metodo sendTemperatureReading usa la classe PnpHelper per creare messaggi per ogni componente:

Message message = PnpHelper.createIotHubMessageUtf8(telemetryName, currentTemperature, componentName);

La classe PnpHelper contiene altri metodi di esempio che è possibile usare con un modello a più componenti.

Usare lo strumento Azure IoT Explorer per visualizzare i dati di telemetria e le proprietà dei due componenti del termostato:

Dispositivo a più componenti in Azure IoT Explorer

È anche possibile usare lo strumento Azure IoT Explorer per chiamare i comandi in uno dei due componenti del termostato o nel componente predefinito.

Questa esercitazione illustra come creare un'applicazione di un dispositivo Plug and Play IoT di esempio con componenti, connetterla all'hub IoT e usare lo strumento Azure IoT Explorer per visualizzare le informazioni inviate all'hub. L'applicazione di esempio è scritta per Node.js ed è inclusa in Azure IoT Hub Device SDK per Node.js. Un integratore di soluzioni può usare lo strumento Azure IoT Explorer per conoscere le funzionalità di un dispositivo Plug and Play IoT senza doverne visualizzare il codice.

Esplora il codice

In questa esercitazione:

  • Scaricare il codice di esempio.
  • Eseguire l'applicazione del dispositivo di esempio e verificare che si connetta all'hub IoT.
  • Esaminare il codice sorgente.

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

Scaricare il codice

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

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

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

Installare le librerie necessarie

Usare l'SDK del dispositivo per compilare il codice di esempio incluso. L'applicazione creata simula un dispositivo Plug and Play con più componenti che si connette a un hub IoT. L'applicazione invia proprietà e dati di telemetria e riceve comandi.

  1. In una finestra del terminale locale passare alla cartella del repository clonato e passare alla cartella /azure-iot-sdk-node/device/samples/javascript . Eseguire quindi il comando seguente per installare le librerie necessarie:
npm install

Questo comando installa i file npm pertinenti necessari per eseguire gli esempi nella cartella .

Esaminare il codice

Passare alla cartella azure-iot-sdk-node/device/samples/javascript .

La cartella azure-iot-sdk-node/device/samples/javascript contiene il codice di esempio per il dispositivo controller di temperatura Plug and Play IoT.

Il codice nel file pnp_temperature_controller.js implementa un dispositivo controller di temperatura Plug and Play IoT. Il modello implementato da questo esempio usa più componenti. Il file del modello DTDL (Digital Twins Definition Language) per il dispositivo temperature definisce i dati di telemetria, le proprietà e i comandi implementati dal dispositivo.

Aprire il file pnp_temperature_controller.js in un editor di codice di propria scelta. Il codice di esempio illustra come:

  • Definire l'oggetto modelId che rappresenta il DTMI per il dispositivo che si sta implementando. Questo DTMI è definito dall'utente e deve corrispondere a quello del modello DTDL del dispositivo termoregolatore.

  • Implementare i componenti definiti nel modello DTDL del dispositivo termoregolatore. I componenti di un dispositivo termoregolatore reale dovranno implementare queste due interfacce. Queste due interfacce sono già pubblicate in un repository centrale. In questo esempio, le due interfacce sono:

    • Thermostat
    • Informazioni sul dispositivo sviluppate da Azure

  • Definire i nomi dei componenti. Questo esempio include due termostati e un componente di informazioni sul dispositivo.

  • Definire i nomi dei comandi per i comandi a cui risponde il dispositivo.

  • Definire la costante serialNumber. serialNumber è un valore fisso in qualsiasi dispositivo specifico.

  • Definire i gestori dei comandi.

  • Definire le funzioni per inviare le risposte ai comandi.

  • Definire le funzioni helper per registrare le richieste dei comandi.

  • Definire una funzione helper per creare le proprietà.

  • Definire un listener per gli aggiornamenti delle proprietà.

  • Definire una funzione per inviare dati di telemetria da questo dispositivo. Sia i termostati che il componente predefinito inviano dati di telemetria. Questa funzione riceve il nome del componente come parametro.

  • Definire una funzione main che:

    • Usa l'SDK del dispositivo per creare un client del dispositivo e connettersi all'hub IoT. Il dispositivo fornisce il valore di modelId in modo che possa essere identificato dall'hub IoT come dispositivo Plug and Play IoT.

    • Avvia l'ascolto di richieste dei comandi tramite la funzione onDeviceMethod. La funzione configura un listener per le richieste dei comandi provenienti dal servizio:

      • Il DTDL del dispositivo definisce i comandi reboot e getMaxMinReport.
      • La funzione commandHandler definisce il modo in cui il dispositivo risponde a un comando.

    • Avvia l'invio dei dati di telemetria usando setInterval e sendTelemetry.

    • Usa la funzione helperCreateReportedPropertiesPatch per creare le proprietà e updateComponentReportedProperties per aggiornarle.

    • Usa desiredPropertyPatchListener per restare in ascolto di aggiornamenti delle proprietà.

    • Disabilita tutti i listener e le attività ed esce dal ciclo quando si preme Q o q.

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.

Dopo avere esaminato il codice, usare il comando seguente per eseguire l'esempio:

node pnp_temperature_controller.js

Viene visualizzato l'output seguente, che indica che il dispositivo ha iniziato a inviare dati di telemetria all'hub ed è ora pronto a ricevere comandi e aggiornamenti delle proprietà.

Messaggi di conferma del dispositivo

Lasciare l'esempio in esecuzione mentre si completano i passaggi successivi.

Usare Azure IoT Explorer per convalidare il codice

Dopo l'avvio dell'esempio client del dispositivo, usare lo strumento Azure IoT Explorer per verificarne il funzionamento.

  1. Aprire Azure IoT Explorer.

  2. Nella pagina Hub IoT, se non è già stata aggiunta una connessione all'hub IoT, selezionare + Aggiungi connessione. Immettere la stringa di connessione per l'hub IoT creato in precedenza e selezionare Salva.

  3. Nella pagina Impostazioni Plug and Play IoT selezionare + Aggiungi > cartella locale e selezionare la cartella modelli locale in cui sono stati salvati i file del modello.

  4. Nella pagina Hub IoT fare clic sul nome dell'hub che si vuole usare. Viene visualizzato un elenco dei dispositivi registrati nell'hub IoT.

  5. Fare clic sull'ID dispositivo del dispositivo creato in precedenza.

  6. Il menu a sinistra mostra i diversi tipi di informazioni disponibili per il dispositivo.

  7. Selezionare Componenti Plug and Play IoT per visualizzare le informazioni sul modello del dispositivo.

  8. È possibile visualizzare i diversi componenti del dispositivo. Componente predefinito ed eventuali componenti aggiuntivi. Selezionare un componente da usare.

  9. Selezionare la pagina Telemetria e quindi selezionare Avvia per visualizzare i dati di telemetria inviati dal dispositivo per questo componente.

  10. Selezionare la pagina Proprietà (solo lettura) per visualizzare le proprietà di sola lettura segnalate per questo componente.

  11. Selezionare la pagina Properties (writable) (Proprietà - accessibili in scrittura) per visualizzare le proprietà accessibili in scrittura che è possibile aggiornare per questo componente.

  12. Selezionare una proprietà in base al nome, immettere un nuovo valore e selezionare Update desired value (Aggiorna valore desiderato).

  13. Per visualizzare il nuovo valore, selezionare il pulsante Aggiorna.

  14. Selezionare la pagina Comandi per visualizzare tutti i comandi per questo componente.

  15. Selezionare il comando di cui si vuole testare l'impostazione del parametro, se presente. Selezionare Invia comando per chiamare il comando nel dispositivo. Nella finestra del prompt dei comandi in cui è in esecuzione il codice di esempio si vedrà che il dispositivo risponde al comando.

Questa esercitazione illustra come creare un'applicazione di un dispositivo Plug and Play IoT di esempio con componenti, connetterla all'hub IoT e usare lo strumento Azure IoT Explorer per visualizzare le informazioni inviate all'hub. L'applicazione di esempio è scritta per Python ed è inclusa in Azure IoT SDK per dispositivi per Python. Un integratore di soluzioni può usare lo strumento Azure IoT Explorer per conoscere le funzionalità di un dispositivo Plug and Play IoT senza doverne visualizzare il codice.

Esplora il codice

In questa esercitazione:

  • Scaricare il codice di esempio.
  • Eseguire l'applicazione del dispositivo di esempio e verificare che si connetta all'hub IoT.
  • Esaminare il codice sorgente.

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 '\'.

Per completare questa esercitazione, è necessario che Python sia installato nel computer di sviluppo. Verifica i requisiti della versione corrente di Python consultando l'Azure IoT SDK per 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.

Scaricare il codice

Il pacchetto azure-iot-device è pubblicato come PIP.

Nell'ambiente Python locale installare il pacchetto nel modo seguente:

pip install azure-iot-device

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

Clonare il repository IoT di Python SDK:

git clone --branch v2 https://github.com/Azure/azure-iot-sdk-python

Esaminare il codice

Questo esempio implementa un dispositivo termoregolatore Plug and Play IoT. Il modello implementato da questo esempio usa più componenti. Il file del modello DTDL (Digital Twins Definition Language) per il dispositivo temperature definisce i dati di telemetria, le proprietà e i comandi implementati dal dispositivo.

La cartella azure-iot-sdk-python/samples/pnp contiene il codice di esempio per il dispositivo Plug and Play IoT. I file per l'esempio di dispositivo termoregolatore sono:

  • temp_controller_with_thermostats.py
  • pnp_helper.py

Il dispositivo termoregolatore include più componenti e un componente predefinito ed è basato sul modello DTDL.

Aprire il file temp_controller_with_thermostats.py in un editor a scelta. Il codice di questo file:

  1. Importa pnp_helper.py per ottenere l'accesso ai metodi helper.

  2. Definisce due identificatori DTMI (Digital Twin Model Identifier) che rappresentano in modo univoco due interfacce diverse, definite nel modello DTDL. I componenti di un dispositivo termoregolatore reale dovranno implementare queste due interfacce. Queste due interfacce sono già pubblicate in un repository centrale. Questi DTMI devono essere noti all'utente e variano in base allo scenario di implementazione del dispositivo. Per l'esempio corrente, queste due interfacce rappresentano:

    • Un termostato
    • Informazioni sul dispositivo sviluppate da Azure.

  3. Definisce il DTMI model_id per il dispositivo da implementare. Il DTMI è definito dall'utente e deve corrispondere al DTMI nel file del modello DTDL.

  4. Definisce i nomi assegnati ai componenti nel file DTDL. Nel DTDL sono inclusi due termostati e un componente di informazioni sul dispositivo. Nel componente predefinito viene anche definita una costante denominata serial_number. Non è possibile cambiare serial_number per un dispositivo.

  5. Definisce le implementazioni del gestore comandi, Questi gestori definiscono le operazioni eseguite dal dispositivo quando riceve le richieste di comando.

  6. Definisce le funzioni per la creazione della risposta a un comando, Queste funzioni definiscono il modo in cui il dispositivo risponde alle richieste di comando. Creare le funzioni di risposta ai comandi se un comando deve inviare una risposta personalizzata all'hub IoT. Se non viene specificata una funzione di risposta per un comando, viene inviata una risposta generica. In questo esempio solo il comando getMaxMinReport include una risposta personalizzata.

  7. Definisce una funzione per l'invio di dati di telemetria da questo dispositivo. Sia i termostati che il componente predefinito inviano dati di telemetria. Questa funzione ha un parametro facoltativo per il nome del componente per consentire all'utente di identificare il componente che ha inviato i dati di telemetria.

  8. Definisce un listener per le richieste dei comandi.

  9. Definisce un listener per gli aggiornamenti delle proprietà desiderati.

  10. Include una funzione main che:

    • Usa l'SDK del dispositivo per creare un client del dispositivo e connettersi all'hub IoT. Il dispositivo invia model_id in modo che possa essere identificato dall'hub IoT come dispositivo Plug and Play IoT.

    • Usa la funzione create_reported_properties nel file helper per creare le proprietà. Passare il nome del componente e le proprietà come coppie chiave-valore a questa funzione.

    • Aggiorna le proprietà leggibili per i relativi componenti chiamando patch_twin_reported_properties.

    • Avvia l'ascolto di richieste dei comandi tramite la funzione execute_command_listener. La funzione configura un listener per le richieste dei comandi provenienti dal servizio. Quando si configura il listener, si specifica un method_nameoggetto , user_command_handlere un oggetto facoltativo create_user_response_handler come parametri.

      • method_name definisce la richiesta del comando. In questo esempio il modello definisce i comandi riavviati e getMaxMinReport.
      • La funzione user_command_handler definisce l'operazione che il dispositivo deve eseguire quando riceve un comando.
      • La funzione create_user_response_handler crea una risposta da inviare all'hub IoT quando un comando viene eseguito correttamente. È possibile visualizzare questa risposta nel portale. Se questa funzione non viene specificata, al servizio viene inviata una risposta generica.

    • Usa execute_property_listener per restare in ascolto di aggiornamenti delle proprietà.

    • Avvia l'invio di dati di telemetria tramite send_telemetry. Il codice di esempio usa un ciclo per chiamare tre funzioni di invio di dati di telemetria. Ciascuna di esse viene chiamata ogni otto secondi

    • Disabilita tutti i listener e le attività ed esce dal ciclo quando si preme Q o q.

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.

Usare il comando seguente per eseguire l'esempio:

python temp_controller_with_thermostats.py

Il dispositivo di esempio invia messaggi di telemetria a intervalli di pochi secondi all'hub IoT.

Viene visualizzato l'output seguente, che indica che il dispositivo invia dati di telemetria all'hub ed è ora pronto a ricevere comandi e aggiornamenti delle proprietà.

Messaggi di conferma del dispositivo

Lasciare l'esempio in esecuzione mentre si completano i passaggi successivi.

Usare Azure IoT Explorer per convalidare il codice

Dopo l'avvio dell'esempio client del dispositivo, usare lo strumento Azure IoT Explorer per verificarne il funzionamento.

  1. Aprire Azure IoT Explorer.

  2. Nella pagina Hub IoT, se non è già stata aggiunta una connessione all'hub IoT, selezionare + Aggiungi connessione. Immettere la stringa di connessione per l'hub IoT creato in precedenza e selezionare Salva.

  3. Nella pagina Impostazioni Plug and Play IoT selezionare + Aggiungi > cartella locale e selezionare la cartella modelli locale in cui sono stati salvati i file del modello.

  4. Nella pagina Hub IoT fare clic sul nome dell'hub che si vuole usare. Viene visualizzato un elenco dei dispositivi registrati nell'hub IoT.

  5. Fare clic sull'ID dispositivo del dispositivo creato in precedenza.

  6. Il menu a sinistra mostra i diversi tipi di informazioni disponibili per il dispositivo.

  7. Selezionare Componenti Plug and Play IoT per visualizzare le informazioni sul modello del dispositivo.

  8. È possibile visualizzare i diversi componenti del dispositivo. Componente predefinito ed eventuali componenti aggiuntivi. Selezionare un componente da usare.

  9. Selezionare la pagina Telemetria e quindi selezionare Avvia per visualizzare i dati di telemetria inviati dal dispositivo per questo componente.

  10. Selezionare la pagina Proprietà (solo lettura) per visualizzare le proprietà di sola lettura segnalate per questo componente.

  11. Selezionare la pagina Properties (writable) (Proprietà - accessibili in scrittura) per visualizzare le proprietà accessibili in scrittura che è possibile aggiornare per questo componente.

  12. Selezionare una proprietà in base al nome, immettere un nuovo valore e selezionare Update desired value (Aggiorna valore desiderato).

  13. Per visualizzare il nuovo valore, selezionare il pulsante Aggiorna.

  14. Selezionare la pagina Comandi per visualizzare tutti i comandi per questo componente.

  15. Selezionare il comando di cui si vuole testare l'impostazione del parametro, se presente. Selezionare Invia comando per chiamare il comando nel dispositivo. Nella finestra del prompt dei comandi in cui è in esecuzione il codice di esempio si vedrà che il dispositivo risponde al comando.

Pulire le risorse

Se si prevede di continuare con altri articoli per sviluppatori di dispositivi, è possibile conservare e riutilizzare le risorse usate in questo articolo. In caso contrario, è possibile eliminare le risorse create in questo articolo per evitare altri addebiti.

È possibile eliminare l'hub e il dispositivo registrato contemporaneamente eliminando l'intero gruppo di risorse con il comando dell'interfaccia della riga di comando di Azure seguente. Non usare questo comando se queste risorse condividono un gruppo di risorse con altre risorse che si vogliono conservare.

az group delete --name <YourResourceGroupName>

Per eliminare solo l'hub IoT, eseguire questo comando usando l'interfaccia della riga di comando di Azure:

az iot hub delete --name <YourIoTHubName>

Per eliminare solo l'identità del dispositivo registrato con l'hub IoT, eseguire questo comando usando l'interfaccia della riga di comando di Azure:

az iot hub device-identity delete --hub-name <YourIoTHubName> --device-id <YourDeviceID>

È anche possibile rimuovere dal computer di sviluppo i file di esempio clonati.

Passaggi successivi

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

Guida per sviluppatori alla modellazione di Plug and Play IoT