Connettere il dispositivo alla soluzione preconfigurata per il monitoraggio remoto (Windows)Connect your device to the remote monitoring preconfigured solution (Windows)

In questa esercitazione viene implementato un dispositivo Chiller che invia i dati di telemetria seguenti alla soluzione di monitoraggio remoto preconfigurata:In this tutorial, you implement a Chiller device that sends the following telemetry to the remote monitoring preconfigured solution:

  • TemperaturaTemperature
  • PressionePressure
  • UmiditàHumidity

Per semplicità, il codice genera valori di telemetria di esempio per il chiller.For simplicity, the code generates sample telemetry values for the Chiller. È possibile estendere l'esempio connettendo sensori reali al dispositivo e inviando dati di telemetria reali.You could extend the sample by connecting real sensors to your device and sending real telemetry.

Il dispositivo di esempio inoltre:The sample device also:

  • Invia i metadati alla soluzione per descrivere le proprie funzionalità.Sends metadata to the solution to describe its capabilities.
  • Risponde alle azioni attivate dalla pagina Dispositivi della soluzione.Responds to actions triggered from the Devices page in the solution.
  • Risponde alle modifiche di configurazione inviate dalla pagina Dispositivi della soluzione.Responds to configuration changes send from the Devices page in the solution.

Per completare l'esercitazione, è necessario un account Azure attivo.To complete this tutorial, you need an active Azure account. Se non si dispone di un account, è possibile creare un account di valutazione gratuita in pochi minuti.If you don't have an account, you can create a free trial account in just a couple of minutes. Per informazioni dettagliate, vedere la pagina relativa alla versione di valutazione gratuita di Azure.For details, see Azure Free Trial.

Prima di iniziareBefore you start

Prima di scrivere un codice per il dispositivo, occorre eseguire la soluzione preconfigurata di monitoraggio remoto e poi effettuare il provisioning di un nuovo dispositivo personalizzato all'interno della soluzione in questione.Before you write any code for your device, you must provision your remote monitoring preconfigured solution and provision a new custom device in that solution.

Eseguire il provisioning della soluzione preconfigurata per il monitoraggio remotoProvision your remote monitoring preconfigured solution

Il dispositivo Chiller creato in questa esercitazione invia dati a un'istanza della soluzione preconfigurata per il monitoraggio remoto.The Chiller device you create in this tutorial sends data to an instance of the remote monitoring preconfigured solution. Se nel proprio account Azure non è già stato effettuato il provisioning della soluzione preconfigurata per il monitoraggio remoto, vedere Distribuire la soluzione preconfigurata di monitoraggio remotoIf you haven't already provisioned the remote monitoring preconfigured solution in your Azure account, see Deploy the remote monitoring preconfigured solution

Al termine del processo di provisioning della soluzione di monitoraggio remoto, fare clic su Avvia per aprire il dashboard della soluzione nel browser.When the provisioning process for the remote monitoring solution finishes, click Launch to open the solution dashboard in your browser.

Dashboard della soluzione

Effettuare il provisioning del dispositivo nella soluzione di monitoraggio remotoProvision your device in the remote monitoring solution

Nota

Se è già stato eseguito il provisioning di un dispositivo nella soluzione, è possibile saltare questo passaggio.If you have already provisioned a device in your solution, you can skip this step. Sono necessarie le credenziali del dispositivo quando si crea l'applicazione client.You need the device credentials when you create the client application.

Per connettere un dispositivo alla soluzione preconfigurata, è necessario che identifichi se stesso nell'hub IoT mediante delle credenziali valide.For a device to connect to the preconfigured solution, it must identify itself to IoT Hub using valid credentials. È possibile recuperare le credenziali del dispositivo dalla pagina Dispositivi della soluzione.You can retrieve the device credentials from the solution Devices page. Le istruzioni per includere le credenziali del dispositivo nell'applicazione client sono illustrate più avanti in questa esercitazione.You include the device credentials in your client application later in this tutorial.

Per aggiungere un dispositivo alla soluzione per il monitoraggio remoto, completare i passaggi seguenti nella pagina Dispositivi della soluzione:To add a device to your remote monitoring solution, complete the following steps on the Devices page in the solution:

  1. Passare alla pagina Provisioning e scegliere Fisico per Tipo di dispositivo:Choose Provision, and then choose Physical as the Device type:

    Effettuare il provisioning di un dispositivo fisico

  2. Immettere Fisico-chiller come ID del dispositivo.Enter Physical-chiller as the Device ID. Scegliere le opzioni Chiave simmetrica e Genera chiavi automaticamente:Choose the Symmetric Key and Auto generate keys options:

    Scegliere le opzioni per il dispositivo

Per individuare le credenziali che il dispositivo deve usare per la connessione alla soluzione preconfigurata, passare al portale di Azure nel browser.To locate the credentials your device must use to connect to the preconfigured solution, navigate to the Azure portal in your browser. Accedere alla sottoscrizione.Sign in to your subscription.

  1. Individuare il gruppo di risorse che contiene i servizi di Azure usati dalla soluzione per il monitoraggio remoto.Locate the resource group that contains the Azure services your remote monitoring solution uses. Il nome del gruppo di risorse coincide con quello della soluzione per il monitoraggio remoto della quale si è effettuato il provisioning.The resource group has the same name as the remote monitoring solution you provisioned.

  2. Passare all'hub IoT in questo gruppo di risorse.Navigate to the IoT hub in this resource group. Scegliere quindi Esplora dispositivi:Then choose Device explorer:

    Esplora dispositivi

  3. Scegliere l'ID dispositivocreato nella pagina Dispositivi della soluzione per il monitoraggio remoto.Choose the Device ID you created on the Devices page in the remote monitoring solution.

  4. Prendere nota dei valori di ID dispositivo e Chiave dispositivo.Make a note of the Device ID and Primary key values. Questi valori vengono usati quando si aggiunge codice per connettere il dispositivo alla soluzione.You use these values when you add code to connect your device to the solution.

È stato ora effettuato il provisioning di un dispositivo fisico nella soluzione preconfigurata per il monitoraggio remoto.You have now provisioned a physical device in the remote monitoring preconfigured solution. Nelle sezioni seguenti si implementerà l'applicazione client che usa le credenziali del dispositivo per connettersi alla soluzione.In the following sections, you implement the client application that uses the device credentials to connect to your solution.

L'applicazione client implementa il modello di dispositivo Chiller predefinito.The client application implements the built-in Chiller device model. Un modello di dispositivo per la soluzione preconfigurata specifica le informazioni seguenti per il dispositivo:A preconfigured solution device model specifies the following about a device:

  • Le proprietà che il dispositivo segnala alla soluzione.The properties the device reports to the solution. Ad esempio, un dispositivo Chiller segnala informazioni su firmware e posizione.For example, a Chiller device reports information about its firmware and location.
  • Tipi di dati di telemetria che il dispositivo invia alla soluzione.The types of telemetry the device sends to the solution. Ad esempio, un dispositivo Chiller invia valori di temperatura, umidità e pressione.For example, a Chiller device sends temperature, humidity, and pressure values.
  • I metodi che possono essere pianificati nella soluzione per l'esecuzione nel dispositivo.The methods you can schedule from the solution to run on the device. Un dispositivo Chiller deve ad esempio implementare i metodi Reboot, FirmwareUpdate, EmergencyValveRelease e IncreasePressure.For example, a Chiller device must implement Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressuree methods.

Questa esercitazione mostra come connettere un dispositivo fisico alla soluzione preconfigurata di monitoraggio remoto.This tutorial shows you how to connect a physical device to the remote monitoring preconfigured solution.

Creare una soluzione client C in WindowsCreate a C client solution on Windows

Come per la maggior parte delle applicazioni incorporate in esecuzione su dispositivi vincolati, il codice client per l'applicazione del dispositivo è scritto in C. In questa esercitazione si compilerà l'applicazione in un computer che esegue Windows.As with most embedded applications that run on constrained devices, the client code for the device application is written in C. In this tutorial, you build the application on a machine running Windows.

Creare il progetto inizialeCreate the starter project

Creare un progetto iniziale in Visual Studio 2017 e aggiungere i pacchetti NuGet del client dispositivo dell'hub IoT:Create a starter project in Visual Studio 2017 and add the IoT Hub device client NuGet packages:

  1. In Visual Studio creare un'applicazione console C usando il modello Applicazione console Windows di Visual C++.In Visual Studio, create a C console application using the Visual C++ Windows Console Application template. Assegnare al progetto il nome RMDevice.Name the project RMDevice.

    Creare un'applicazione console Windows in Visual C++

  2. In Esplora soluzionieliminare i file stdafx.h, targetver.h e stdafx.cpp.In Solution Explorer, delete the files stdafx.h, targetver.h, and stdafx.cpp.

  3. In Esplora soluzionirinominare il file RMDevice.cpp in RMDevice.c.In Solution Explorer, rename the file RMDevice.cpp to RMDevice.c.

    Esplora soluzioni mostra il file RMDevice.c rinominato

  4. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto RMDevice e quindi scegliere Gestisci pacchetti NuGet.In Solution Explorer, right-click the RMDevice project and then click Manage NuGet packages. Scegliere Sfoglia, quindi cercare e installare i pacchetti NuGet seguenti:Choose Browse, then search for and install the following NuGet packages:

    • Microsoft.Azure.IoTHub.SerializerMicrosoft.Azure.IoTHub.Serializer
    • Microsoft.Azure.IoTHub.IoTHubClientMicrosoft.Azure.IoTHub.IoTHubClient
    • Microsoft.Azure.IoTHub.MqttTransportMicrosoft.Azure.IoTHub.MqttTransport

      Gestione pacchetti NuGet mostra i pacchetti Microsoft.Azure.IoTHub installati

  5. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto RMDevice e quindi scegliere Proprietà per aprire la finestra di dialogo Pagine delle proprietà del progetto.In Solution Explorer, right-click on the RMDevice project and then choose Properties to open the project's Property Pages dialog box. Per informazioni dettagliate, vedere Setting Visual C++ Project Properties (Impostazione delle proprietà dei progetti Visual C++).For details, see Setting Visual C++ Project Properties.

  6. Scegliere la cartella C/C++ e quindi la pagina delle proprietà Intestazioni precompilate.Choose the C/C++ folder, then choose the Precompiled Headers property page.

  7. Impostare Intestazione precompilata su Senza intestazioni precompilate.Set Precompiled Header to Not Using Precompiled Headers. Scegliere quindi Applica.Then choose Apply.

    Proprietà del progetto che mostrano l'opzione Senza intestazioni precompilate

  8. Scegliere la cartella Linker e quindi fare clic sulla pagina delle proprietà Input.Choose the Linker folder, then choose the Input property page.

  9. Aggiungere crypt32.lib alla proprietà Dipendenze aggiuntive.Add crypt32.lib to the Additional Dependencies property. Per salvare i valori delle proprietà del progetto, scegliere OK e quindi di nuovo OK.To save the project property values, choose OK and then OK again.

    Proprietà del progetto che mostrano la cartella Linker che include crypt32.lib

Installare la raccolta JSON ParsonAdd the Parson JSON library

Aggiungere la libreria Parson JSON al progetto RMDevice e aggiungere le istruzioni #include richieste:Add the Parson JSON library to the RMDevice project and add the required #include statements:

  1. In una cartella appropriata nel computer, clonare il repository Parson GitHub usando il comando seguente:In a suitable folder on your computer, clone the Parson GitHub repository using the following command:

    git clone https://github.com/kgabis/parson.git
    
  2. Copiare i file parson.h e parson.c dalla copia locale del repository Parson alla cartella del progetto RMDevice.Copy the parson.h and parson.c files from the local copy of the Parson repository to your RMDevice project folder.

  3. In Visual Studio fare clic con il pulsante destro del mouse sul progetto RMDevice, scegliere Aggiungi e quindi Elemento esistente.In Visual Studio, right-click the RMDevice project, choose Add, and then choose Existing Item.

  4. Nella finestra di dialogo Aggiungi elemento esistente selezionare i file parson.h e parson.c nella cartella del progetto RMDevice.In the Add Existing Item dialog, select the parson.h and parson.c files in the RMDevice project folder. Per aggiungere questi due file al progetto, scegliere Aggiungi.To add these two files to your project, choose Add.

    Esplora soluzioni mostra i file parson.h e parson.c

  5. In Visual Studio aprire il file RMDevice.c.In Visual Studio, open the RMDevice.c file. Sostituire le istruzioni #include esistenti con il codice seguente:Replace the existing #include statements with the following code:

    #include "iothubtransportmqtt.h"
    #include "schemalib.h"
    #include "iothub_client.h"
    #include "serializer_devicetwin.h"
    #include "schemaserializer.h"
    #include "azure_c_shared_utility/threadapi.h"
    #include "azure_c_shared_utility/platform.h"
    #include "parson.h"
    

    Nota

    È ora possibile verificare che per il progetto siano configurate le dipendenze corrette compilando la soluzione.Now you can verify that your project has the correct dependencies set up by building the solution.

Specificare il comportamento del dispositivo IoTSpecify the behavior of the IoT device

La libreria client serializzatrice di hub IoT usa un modello per specificare il formato dei messaggi che il dispositivo scambia con hub IoT.The IoT Hub serializer client library uses a model to specify the format of the messages the device exchanges with IoT Hub.

  1. Aggiungere le seguenti dichiarazioni di variabili dopo le istruzioni #include .Add the following variable declarations after the #include statements. Sostituire i valori segnaposto [Device Id] e [Device Key] con i valori annotati per il dispositivo nel dashboard della soluzione di monitoraggio remoto.Replace the placeholder values [Device Id] and [Device Key] with the values you noted for your device in the remote monitoring solution dashboard. Usare il nome host hub IoT del dashboard della soluzione per sostituire [IoTHub Name].Use the IoT Hub Hostname from the solution dashboard to replace [IoTHub Name]. Ad esempio, se il nome host dell'hub IoT è contoso.azure-devices.net, sostituire [Nome IoTHub] con contoso:For example, if your IoT Hub Hostname is contoso.azure-devices.net, replace [IoTHub Name] with contoso:

    static const char* deviceId = "[Device Id]";
    static const char* connectionString = "HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]";
    static char propText[1024];
    
  2. Aggiungere il codice seguente per definire il modello che consente al dispositivo di comunicare con l'hub IoT.Add the following code to define the model that enables the device to communicate with IoT Hub. Questo modello consente di specificare che il dispositivo:This model specifies that the device:

    • Può inviare umidità, temperatura e pressione come dati di telemetria.Can send temperature, pressure, and humidity as telemetry.
    • Può inviare proprietà segnalate al dispositivo gemello nell'hub IoT.Can send reported properties, to the device twin in IoT Hub. Queste proprietà segnalate includono informazioni sullo schema di telemetria e sui metodi supportati.These reported properties include information about the telemetry schema and supported methods.
    • Può ricevere e agire sulle proprietà desiderate impostate nel dispositivo gemello nell'hub IoT.Can receive and act on desired properties set in the device twin in IoT Hub.
    • Può rispondere ai metodi diretti Reboot, FirmwareUpdate, EmergencyValveRelease e IncreasePressure richiamati dall'interfaccia utente.Can respond to the Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressure direct methods invoked from the UI. Il dispositivo invia le informazioni sui metodi diretti che supporta usando le proprietà segnalate.The device sends information about the direct methods it supports using reported properties.

      // Define the Model
      BEGIN_NAMESPACE(Contoso);
      
      DECLARE_STRUCT(MessageSchema,
      ascii_char_ptr, Name,
      ascii_char_ptr, Format,
      ascii_char_ptr_no_quotes, Fields
      )
      
      DECLARE_STRUCT(TelemetrySchema,
      ascii_char_ptr, Interval,
      ascii_char_ptr, MessageTemplate,
      MessageSchema, MessageSchema
      )
      
      DECLARE_STRUCT(TelemetryProperties,
      TelemetrySchema, TemperatureSchema,
      TelemetrySchema, HumiditySchema,
      TelemetrySchema, PressureSchema
      )
      
      DECLARE_DEVICETWIN_MODEL(Chiller,
      /* Telemetry (temperature, external temperature and humidity) */
      WITH_DATA(double, temperature),
      WITH_DATA(ascii_char_ptr, temperature_unit),
      WITH_DATA(double, pressure),
      WITH_DATA(ascii_char_ptr, pressure_unit),
      WITH_DATA(double, humidity),
      WITH_DATA(ascii_char_ptr, humidity_unit),
      
      /* Device twin properties */
      WITH_REPORTED_PROPERTY(ascii_char_ptr, Protocol),
      WITH_REPORTED_PROPERTY(ascii_char_ptr, SupportedMethods),
      WITH_REPORTED_PROPERTY(TelemetryProperties, Telemetry),
      WITH_REPORTED_PROPERTY(ascii_char_ptr, Type),
      WITH_REPORTED_PROPERTY(ascii_char_ptr, Firmware),
      WITH_REPORTED_PROPERTY(ascii_char_ptr, FirmwareUpdateStatus),
      WITH_REPORTED_PROPERTY(ascii_char_ptr, Location),
      WITH_REPORTED_PROPERTY(double, Latitiude),
      WITH_REPORTED_PROPERTY(double, Longitude),
      
      WITH_DESIRED_PROPERTY(ascii_char_ptr, Interval, onDesiredInterval),
      
      /* Direct methods implemented by the device */
      WITH_METHOD(Reboot),
      WITH_METHOD(FirmwareUpdate),
      WITH_METHOD(EmergencyValveRelease),
      WITH_METHOD(IncreasePressure)
      );
      
      END_NAMESPACE(Contoso);
      

Implementare il comportamento del dispositivoImplement the behavior of the device

Aggiungere il codice che implementa il comportamento definito nel modello.Now add code that implements the behavior defined in the model.

  1. Aggiungere le funzioni seguenti che gestiscono le proprietà desiderate impostate nel dashboard della soluzione.Add the following functions that handle the desired properties set in the solution dashboard. Tali proprietà desiderate sono definite nel modello:These desired properties are defined in the model:

    void onDesiredInterval(void* argument)
    {
      /* By convention 'argument' is of the type of the MODEL */
      Chiller* chiller = argument;
      printf("Received a new desired Interval value: %s \r\n", chiller->Interval);
    }
    
  2. Aggiungere le funzioni seguenti che gestiscono i metodi diretti richiamati tramite l'hub IoT.Add the following functions that handle the direct methods invoked through the IoT hub. Questi metodi diretti sono definiti nel modello:These direct methods are defined in the model:

    /* Handlers for direct methods */
    METHODRETURN_HANDLE Reboot(Chiller* chiller)
    {
      (void)(chiller);
    
      METHODRETURN_HANDLE result = MethodReturn_Create(201, "\"Rebooting\"");
      printf("Received reboot request\r\n");
      return result;
    }
    
    METHODRETURN_HANDLE FirmwareUpdate(Chiller* chiller)
    {
      (void)(chiller);
    
      METHODRETURN_HANDLE result = MethodReturn_Create(201, "\"Updating Firmware\"");
      printf("Recieved firmware update request\r\n");
      return result;
    }
    
    METHODRETURN_HANDLE EmergencyValveRelease(Chiller* chiller)
    {
      (void)(chiller);
    
      METHODRETURN_HANDLE result = MethodReturn_Create(201, "\"Releasing Emergency Valve\"");
      printf("Recieved emergency valve release request\r\n");
      return result;
    }
    
    METHODRETURN_HANDLE IncreasePressure(Chiller* chiller)
    {
      (void)(chiller);
    
      METHODRETURN_HANDLE result = MethodReturn_Create(201, "\"Increasing Pressure\"");
      printf("Received increase pressure request\r\n");
      return result;
    }
    
  3. Aggiungere la funzione seguente che aggiunge una proprietà a un messaggio da dispositivo a cloud:Add the following function that adds a property to a device-to-cloud message:

    /* Add message property */
    static void addProperty(MAP_HANDLE propMap, char* propName, char* propValue)
    {
      if (Map_AddOrUpdate(propMap, propName, propValue) != MAP_OK)
      {
        (void)printf("ERROR: Map_AddOrUpdate Failed on %s!\r\n", propName);
      }
    }
    
  4. Aggiungere la funzione seguente che invia un messaggio con proprietà alla soluzione preconfigurata:Add the following function that sends a message with properties to the preconfigured solution:

    static void sendMessage(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const unsigned char* buffer, size_t size, char* schema)
    {
      IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(buffer, size);
      if (messageHandle == NULL)
      {
        printf("unable to create a new IoTHubMessage\r\n");
      }
      else
      {
        // Add properties
        MAP_HANDLE propMap = IoTHubMessage_Properties(messageHandle);
        addProperty(propMap, "$$MessageSchema", schema);
        addProperty(propMap, "$$ContentType", "JSON");
        time_t now = time(0);
        struct tm* timeinfo;
        #pragma warning(disable: 4996)
        timeinfo = gmtime(&now);
        char timebuff[50];
        strftime(timebuff, 50, "%Y-%m-%dT%H:%M:%SZ", timeinfo);
        addProperty(propMap, "$$CreationTimeUtc", timebuff);
    
        if (IoTHubClient_SendEventAsync(iotHubClientHandle, messageHandle, NULL, NULL) != IOTHUB_CLIENT_OK)
        {
          printf("failed to hand over the message to IoTHubClient");
        }
        else
        {
          printf("IoTHubClient accepted the message for delivery\r\n");
        }
    
        IoTHubMessage_Destroy(messageHandle);
      }
      free((void*)buffer);
    }
    
  5. Aggiungere il gestore di callback seguente che viene eseguito quando il dispositivo ha inviato i nuovi valori di proprietà segnalati alla soluzione preconfigurata:Add the following callback handler that runs when the device has sent new reported property values to the preconfigured solution:

    /* Callback after sending reported properties */
    void deviceTwinCallback(int status_code, void* userContextCallback)
    {
      (void)(userContextCallback);
      printf("IoTHub: reported properties delivered with status_code = %u\n", status_code);
    }
    
  6. Aggiungere la funzione seguente per connettere il dispositivo alla soluzione preconfigurata nel cloud e scambiare dati.Add the following function to connect your device to the preconfigured solution in the cloud, and exchange data. Questa funzione esegue questa procedura:This function performs the following steps:

    • Inizializza la piattaforma.Initializes the platform.
    • Registra lo spazio dei nomi Contoso con la libreria di serializzazione.Registers the Contoso namespace with the serialization library.
    • Inizializza il client con la stringa di connessione del dispositivo.Initializes the client with the device connection string.
    • Creare un'istanza del modello Chiller.Create an instance of the Chiller model.
    • Crea e invia i valori delle proprietà segnalate.Creates and sends reported property values.
    • Crea un ciclo per inviare dati di telemetria ogni cinque secondi.Creates a loop to send telemetry every five seconds.
    • Deinizializza tutte le risorse.Deinitializes all resources.

      void remote_monitoring_run(void)
      {
      if (platform_init() != 0)
      {
        printf("Failed to initialize the platform.\n");
      }
      else
      {
        if (SERIALIZER_REGISTER_NAMESPACE(Contoso) == NULL)
        {
          printf("Unable to SERIALIZER_REGISTER_NAMESPACE\n");
        }
        else
        {
          IOTHUB_CLIENT_HANDLE iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, MQTT_Protocol);
          if (iotHubClientHandle == NULL)
          {
            printf("Failure in IoTHubClient_CreateFromConnectionString\n");
          }
          else
          {
            Chiller* chiller = IoTHubDeviceTwin_CreateChiller(iotHubClientHandle);
            if (chiller == NULL)
            {
              printf("Failure in IoTHubDeviceTwin_CreateChiller\n");
            }
            else
            {
              /* Set values for reported properties */
              chiller->Protocol = "MQTT";
              chiller->SupportedMethods = "Reboot,FirmwareUpdate,EmergencyValveRelease,IncreasePressure";
              chiller->Telemetry.TemperatureSchema.Interval = "00:00:05";
              chiller->Telemetry.TemperatureSchema.MessageTemplate = "{\"temperature\":${temperature},\"temperature_unit\":\"${temperature_unit}\"}";
              chiller->Telemetry.TemperatureSchema.MessageSchema.Name = "chiller-temperature;v1";
              chiller->Telemetry.TemperatureSchema.MessageSchema.Format = "JSON";
              chiller->Telemetry.TemperatureSchema.MessageSchema.Fields = "{\"temperature\":\"Double\",\"temperature_unit\":\"Text\"}";
              chiller->Telemetry.HumiditySchema.Interval = "00:00:05";
              chiller->Telemetry.HumiditySchema.MessageTemplate = "{\"humidity\":${humidity},\"humidity_unit\":\"${humidity_unit}\"}";
              chiller->Telemetry.HumiditySchema.MessageSchema.Name = "chiller-humidity;v1";
              chiller->Telemetry.HumiditySchema.MessageSchema.Format = "JSON";
              chiller->Telemetry.HumiditySchema.MessageSchema.Fields = "{\"humidity\":\"Double\",\"humidity_unit\":\"Text\"}";
              chiller->Telemetry.PressureSchema.Interval = "00:00:05";
              chiller->Telemetry.PressureSchema.MessageTemplate = "{\"pressure\":${pressure},\"pressure_unit\":\"${pressure_unit}\"}";
              chiller->Telemetry.PressureSchema.MessageSchema.Name = "chiller-pressure;v1";
              chiller->Telemetry.PressureSchema.MessageSchema.Format = "JSON";
              chiller->Telemetry.PressureSchema.MessageSchema.Fields = "{\"pressure\":\"Double\",\"pressure_unit\":\"Text\"}";
              chiller->Type = "Chiller";
              chiller->Firmware = "1.0.0";
              chiller->FirmwareUpdateStatus = "";
              chiller->Location = "Building 44";
              chiller->Latitiude = 47.638928;
              chiller->Longitude = -122.13476;
      
              /* Send reported properties to IoT Hub */
              if (IoTHubDeviceTwin_SendReportedStateChiller(chiller, deviceTwinCallback, NULL) != IOTHUB_CLIENT_OK)
              {
                printf("Failed sending serialized reported state\n");
              }
              else
              {
                /* Send telemetry */
                chiller->temperature = 50;
                chiller->temperature_unit = "F";
                chiller->pressure= 55;
                chiller->pressure_unit = "psig";
                chiller->humidity = 50;
                chiller->humidity_unit = "%";
      
                while (1)
                {
                  unsigned char*buffer;
                  size_t bufferSize;
      
                  (void)printf("Sending sensor value Temperature = %f %s,\n", chiller->temperature, chiller->temperature_unit);
      
                  if (SERIALIZE(&buffer, &bufferSize, chiller->temperature, chiller->temperature_unit) != CODEFIRST_OK)
                  {
                    (void)printf("Failed sending sensor value\r\n");
                  }
                  else
                  {
                    sendMessage(iotHubClientHandle, buffer, bufferSize, chiller->Telemetry.TemperatureSchema.MessageSchema.Name);
                  }
      
                  (void)printf("Sending sensor value Humidity = %f %s,\n", chiller->humidity, chiller->humidity_unit);
      
                  if (SERIALIZE(&buffer, &bufferSize, chiller->humidity, chiller->humidity_unit) != CODEFIRST_OK)
                  {
                    (void)printf("Failed sending sensor value\r\n");
                  }
                  else
                  {
                    sendMessage(iotHubClientHandle, buffer, bufferSize, chiller->Telemetry.HumiditySchema.MessageSchema.Name);
                  }
      
                  (void)printf("Sending sensor value Pressure = %f %s,\n", chiller->pressure, chiller->pressure_unit);
      
                  if (SERIALIZE(&buffer, &bufferSize, chiller->pressure, chiller->pressure_unit) != CODEFIRST_OK)
                  {
                    (void)printf("Failed sending sensor value\r\n");
                  }
                  else
                  {
                    sendMessage(iotHubClientHandle, buffer, bufferSize, chiller->Telemetry.PressureSchema.MessageSchema.Name);
                  }
      
                  ThreadAPI_Sleep(5000);
                }
      
                IoTHubDeviceTwin_DestroyChiller(chiller);
              }
            }
            IoTHubClient_Destroy(iotHubClientHandle);
          }
          serializer_deinit();
        }
      }
      platform_deinit();
      }
      

      Per riferimento, ecco un esempio di messaggio di Telemetria inviato alla soluzione preconfigurata:For reference, here is a sample Telemetry message sent to the preconfigured solution:

      Device: [myCDevice],
      Data:[{"humidity":50.000000000000000, "humidity_unit":"%"}]
      Properties:
      '$$MessageSchema': 'chiller-humidity;v1'
      '$$ContentType': 'JSON'
      '$$CreationTimeUtc': '2017-09-12T09:17:13Z'
      

Compilare ed eseguire l'esempioBuild and run the sample

Aggiungere il codice per richiamare la funzione remote_monitoring_run e quindi compilare ed eseguire l'applicazione del dispositivo:Add code to invoke the remote_monitoring_run function, then build and run the device application:

  1. Per richiamare la funzione remote_monitoring_run, sostituire la funzione main con il codice seguente:To invoke the remote_monitoring_run function, replace the main function with following code:

    int main()
    {
      remote_monitoring_run();
      return 0;
    }
    
  2. Scegliere Compila e quindi Compila soluzione per compilare l'applicazione del dispositivo.Choose Build and then Build Solution to build the device application. Ignorare l'avviso relativo alla funzione gmtime.Ignore the warning about the gmtime function.

  3. In Esplora soluzioni fare clic con il pulsante destro del mouse sul progetto RMDevice, scegliere Debug e quindi fare clic su Avvia nuova istanza per eseguire l'esempio.In Solution Explorer, right-click the RMDevice project, choose Debug, and then choose Start new instance to run the sample. La console visualizza messaggi relativi alle operazioni seguenti:The console displays messages as:

    • L'applicazione invia dati di telemetria di esempio alla soluzione preconfigurata.The application sends sample telemetry to the preconfigured solution.
    • Riceve i valori di proprietà desiderati impostati nel dashboard della soluzione.Receives desired property values set in the solution dashboard.
    • Risponde ai metodi richiamati dal dashboard della soluzione.Responds to methods invoked from the solution dashboard.

Visualizzare la telemetria dei dispositiviView device telemetry

È possibile visualizzare i dati di telemetria inviati dal dispositivo nella pagina Dispositivi della soluzione.You can view the telemetry sent from your device on the Devices page in the solution.

  1. Selezionare il dispositivo del quale è stato effettuato il provisioning nell'elenco dei dispositivi della pagina Dispositivi.Select the device you provisioned in the list of devices on the Devices page. Un pannello visualizza le informazioni sul dispositivo, incluso un tracciato dei dati di telemetria del dispositivo:A panel displays information about your device including a plot of the device telemetry:

    Vedere i dettagli del dispositivo

  2. Scegliere Pressione per modificare la visualizzazione dei dati di telemetria:Choose Pressure to change the telemetry display:

    Visualizzare i dati di telemetria per la pressione

  3. Per visualizzare le informazioni di diagnostica sul dispositivo, scorrere fino a Diagnostica:To view diagnostic information about your device, scroll down to Diagnostics:

    Visualizzazione della diagnostica del dispositivo

Agire sul dispositivoAct on your device

Per richiamare i metodi nei dispositivi, usare la pagina Dispositivi della soluzione per il monitoraggio remoto.To invoke methods on your devices, use the Devices page in the remote monitoring solution. Nella soluzione per il monitoraggio remoto, i dispositivi Chiller implementano ad esempio un metodo Reboot.For example, in the remote monitoring solution Chiller devices implement a Reboot method.

  1. Scegliere Dispositivi per passare alla pagina Dispositivi della soluzione.Choose Devices to navigate to the Devices page in the solution.

  2. Selezionare il dispositivo del quale è stato effettuato il provisioning nell'elenco dei dispositivi della pagina Dispositivi:Select the device you provisioned in the list of devices on the Devices page:

    Selezionare il dispositivo fisico

  3. Per visualizzare un elenco dei metodi che è possibile chiamare in un dispositivo, scegliere Pianificazione.To display a list of the methods you can call on your device, choose Schedule. Per pianificare un metodo per l'esecuzione in più dispositivi, è possibile selezionare più dispositivi nell'elenco.To schedule a method to run on multiple devices, you can select multiple devices in the list. Il pannello Pianificazione mostra i tipi di metodi comuni a tutti i dispositivi selezionati.The Schedule panel shows the types of method common to all the devices you selected.

  4. Scegliere Reboot, impostare il nome processo su RebootPhysicalChiller e quindi fare clic su Applica:Choose Reboot, set the job name to RebootPhysicalChiller, and choose Apply:

    Pianificare il riavvio

  5. Viene visualizzato un messaggio nella console che esegue il codice del dispositivo quando il dispositivo gestisce il metodo.A message displays in the console running your device code when the device handles the method.

Nota

Per tenere traccia dello stato del processo nella soluzione, scegliere Visualizza.To track the status of the job in the solution, choose View.

Passaggi successiviNext steps

L'articolo Personalizzare la soluzione preconfigurata di monitoraggio remoto descrive alcuni modi per personalizzare la soluzione preconfigurata.The article Customize the remote monitoring preconfigured solution describes some ways to customize the preconfigured solution.