Ligue o seu dispositivo Raspberry Pi ao acelerador de solução de monitorização remota (C)Connect your Raspberry Pi device to the Remote Monitoring solution accelerator (C)

Neste tutorial, implementa-se um dispositivo Chiller que envia a seguinte telemetria para o acelerador de solução de monitorizaçãoremota:In this tutorial, you implement a Chiller device that sends the following telemetry to the Remote Monitoring solution accelerator:

  • TemperaturaTemperature
  • PressãoPressure
  • HumidadeHumidity

Para simplificar, o código gera valores de telemetria de amostra para o Refrigerador.For simplicity, the code generates sample telemetry values for the Chiller. Pode estender a amostra ligando sensores reais ao seu dispositivo e enviando telemetria real.You could extend the sample by connecting real sensors to your device and sending real telemetry.

O dispositivo de amostra também:The sample device also:

  • Envia metadados para a solução para descrever as suas capacidades.Sends metadata to the solution to describe its capabilities.
  • Responde às ações desencadeadas a partir da página dispositivos na solução.Responds to actions triggered from the Devices page in the solution.
  • Responde às alterações de configuração enviadas a partir da página dispositivos na solução.Responds to configuration changes send from the Devices page in the solution.

Para concluir este tutorial, precisa de uma conta ativa do Azure.To complete this tutorial, you need an active Azure account. Se não tiver uma conta, pode criar uma de avaliação gratuita em apenas alguns minutos.If you don't have an account, you can create a free trial account in just a couple of minutes. Para obter mais detalhes, consulte Avaliação Gratuita do Azure.For details, see Azure Free Trial.

Antes de começarBefore you start

Antes de escrever qualquer código para o seu dispositivo, coloque o acelerador de solução de Monitorização Remota e adicione um novo dispositivo real à solução.Before you write any code for your device, deploy your Remote Monitoring solution accelerator and add a new real device to the solution.

Implemente o seu acelerador de solução de monitorização remotaDeploy your Remote Monitoring solution accelerator

O dispositivo Chiller que cria neste tutorial envia dados para uma instância do acelerador de solução de monitorização remota.The Chiller device you create in this tutorial sends data to an instance of the Remote Monitoring solution accelerator. Se ainda não disponibilizou o acelerador de solução de monitorização remota na sua conta Azure, consulte implementar o acelerador de solução de monitorização remotaIf you haven't already provisioned the Remote Monitoring solution accelerator in your Azure account, see Deploy the Remote Monitoring solution accelerator

Quando o processo de implementação da solução de Monitorização Remota terminar, clique em Lançamento para abrir o painel de instrumentos de solução no seu navegador.When the deployment process for the Remote Monitoring solution finishes, click Launch to open the solution dashboard in your browser.

O painel de solução

Adicione o seu dispositivo à solução de Monitorização RemotaAdd your device to the Remote Monitoring solution

Nota

Se já adicionou um dispositivo na sua solução, pode saltar este passo.If you have already added a device in your solution, you can skip this step. No entanto, o próximo passo requer a cadeia de ligação do dispositivo.However, the next step requires your device connection string. Pode recuperar a cadeia de ligação de um dispositivo a partir do portal Azure ou utilizando a ferramenta Az iot CLI.You can retrieve a device's connection string from the Azure portal or using the az iot CLI tool.

Para que um dispositivo se conecte ao acelerador de solução, deve identificar-se ao IoT Hub utilizando credenciais válidas.For a device to connect to the solution accelerator, it must identify itself to IoT Hub using valid credentials. Tem a oportunidade de guardar a cadeia de ligação do dispositivo que contém estas credenciais quando adiciona o dispositivo à solução.You have the opportunity to save the device connection string that contains these credentials when you add the device to the solution. Inclui a cadeia de ligação do dispositivo na aplicação do seu cliente mais tarde neste tutorial.You include the device connection string in your client application later in this tutorial.

Para adicionar um dispositivo à sua solução de Monitorização Remota, complete os seguintes passos na página do Explorador do Dispositivo na solução:To add a device to your Remote Monitoring solution, complete the following steps on the Device Explorer page in the solution:

  1. Escolha + novo dispositivo, e depois escolha Real como tipo dispositivo:Choose + New device, and then choose Real as the Device type:

    Adicionar um dispositivo real

  2. Introduza o refrigerador físico como o ID do dispositivo.Enter Physical-chiller as the Device ID. Escolha a chave simétrica e as opções de teclas de geração automática:Choose the Symmetric Key and Auto generate keys options:

    Escolha as opções do dispositivo

  3. Escolha Aplicar.Choose Apply. Em seguida, tome nota dos valores de chave primária do dispositivo, ID, chave primáriae ligação:Then make a note of the Device ID, Primary Key, and Connection string primary key values:

    Obter credenciais

Adicionou agora um dispositivo real ao acelerador de solução de monitorização remota e observou a sua cadeia de ligação do dispositivo.You've now added a real device to the Remote Monitoring solution accelerator and noted its device connection string. Nas secções seguintes, implementa a aplicação do cliente que utiliza o fio de ligação do dispositivo para se ligar à sua solução.In the following sections, you implement the client application that uses the device connection string to connect to your solution.

A aplicação do cliente implementa o modelo de dispositivo Chiller incorporado.The client application implements the built-in Chiller device model. Um modelo de dispositivo acelerador de solução especifica o seguinte sobre um dispositivo:A solution accelerator device model specifies the following about a device:

  • As propriedades que o dispositivo reporta à solução.The properties the device reports to the solution. Por exemplo, um dispositivo Chiller informa informações sobre o seu firmware e localização.For example, a Chiller device reports information about its firmware and location.
  • Os tipos de telemetria que o dispositivo envia para a solução.The types of telemetry the device sends to the solution. Por exemplo, um dispositivo Chiller envia valores de temperatura, humidade e pressão.For example, a Chiller device sends temperature, humidity, and pressure values.
  • Os métodos que pode agendar a partir da solução para executar no dispositivo.The methods you can schedule from the solution to run on the device. Por exemplo, um dispositivo Chiller deve implementar métodos Reboot, FirmwareUpdate, EmergencyValveReleasee IncreasePressure.For example, a Chiller device must implement Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressure methods.

Este tutorial mostra-lhe como ligar um dispositivo real ao acelerador de solução de monitorização remota.This tutorial shows you how to connect a real device to the Remote Monitoring solution accelerator. Tal como acontece com a maioria das aplicações incorporadas que funcionam em dispositivos constrangidos, o código de cliente para a aplicação do dispositivo Raspberry Pi está escrito em C. Neste tutorial, você constrói a aplicação em um Raspberry Pi executando o Raspbian OS.As with most embedded applications that run on constrained devices, the client code for the Raspberry Pi device application is written in C. In this tutorial, you build the application on a Raspberry Pi running the Raspbian OS.

Se preferir simular um dispositivo, consulte criar e testar um novo dispositivo simulado.If you prefer to simulate a device, see Create and test a new simulated device.

Hardware necessárioRequired hardware

Um computador de secretária que lhe permite ligar remotamente à linha de comando do Raspberry Pi.A desktop computer to enable you to connect remotely to the command line on the Raspberry Pi.

Kit de arranque Microsoft IoT para raspberry Pi 3 ou componentes equivalentes.Microsoft IoT Starter Kit for Raspberry Pi 3 or equivalent components. Este tutorial utiliza os seguintes itens do kit:This tutorial uses the following items from the kit:

  • Framboesa Pi 3Raspberry Pi 3
  • Cartão MicroSD (com NOOBS)MicroSD Card (with NOOBS)
  • Um mini cabo USBA USB Mini cable
  • Um cabo EthernetAn Ethernet cable

Software de ambiente de trabalho necessárioRequired desktop software

Precisa de um cliente SSH na sua máquina de ambiente de trabalho para lhe permitir aceder remotamente à linha de comando do Raspberry Pi.You need SSH client on your desktop machine to enable you to remotely access the command line on the Raspberry Pi.

  • O Windows não inclui um cliente SSH.Windows does not include an SSH client. Recomendamos a utilização de PuTTY.We recommend using PuTTY.
  • A maioria das distribuições linux e Mac OS incluem o utilitário SSH de linha de comando.Most Linux distributions and Mac OS include the command-line SSH utility. Para obter mais informações, consulte SSH Usando Linux ou Mac OS.For more information, see SSH Using Linux or Mac OS.

Software Raspberry Pi obrigatórioRequired Raspberry Pi software

Este artigo pressupõe que instalou a versão mais recente do Sistema Raspbian no seu Raspberry Pi.This article assumes you have installed the latest version of the Raspbian OS on your Raspberry Pi.

Os seguintes passos mostram-lhe como preparar o seu Raspberry Pi para a construção de uma aplicação C que se conecta ao acelerador de solução:The following steps show you how to prepare your Raspberry Pi for building a C application that connects to the solution accelerator:

  1. Ligue-se ao seu Raspberry Pi usando ssh.Connect to your Raspberry Pi using ssh. Para mais informações, consulte SSH (Secure Shell) no site raspberry Pi.For more information, see SSH (Secure Shell) on the Raspberry Pi website.

  2. Utilize o seguinte comando para atualizar o seu Raspberry Pi:Use the following command to update your Raspberry Pi:

    sudo apt-get update
    
  3. Para completar os passos neste guia de como guiar siga os passos na configuração do seu ambiente de desenvolvimento Linux para adicionar as ferramentas e bibliotecas de desenvolvimento necessárias ao seu Raspberry Pi.To complete the steps in this how-to guide follow the steps in set up your Linux development environment to add the required development tools and libraries to your Raspberry Pi.

Ver o códigoView the code

O código de amostra utilizado neste guia está disponível no repositório Azure IoT C SDKs GitHub.The sample code used in this guide is available in the Azure IoT C SDKs GitHub repository.

Descarregue o código fonte e prepare o projetoDownload the source code and prepare the project

Para preparar o projeto, clone ou descarregue o repositório Azure IoT C SDKs do GitHub.To prepare the project, clone or download the Azure IoT C SDKs repository from GitHub.

A amostra encontra-se na pasta amostras/soluções/remote_monitoring_client.The sample is located in the samples/solutions/remote_monitoring_client folder.

Abra o ficheiro remote_monitoring.c na pasta samples/solutions/remote_monitoring_client num editor de texto.Open the remote_monitoring.c file in the samples/solutions/remote_monitoring_client folder in a text editor.

Instruções de códigoCode walkthrough

Esta secção descreve algumas das partes-chave do código de amostra e explica como se relacionam com o acelerador de solução de monitorização remota.This section describes some of the key parts of the sample code and explains how they relate to the Remote Monitoring solution accelerator.

O seguinte corte mostra como as propriedades relatadas que descrevem as capacidades do dispositivo são definidas.The following snippet shows how the reported properties that describe the capabilities of the device are defined. Estas propriedades incluem:These properties include:

  • A localização do dispositivo para permitir que o acelerador de solução adicione o dispositivo ao mapa.The location of the device to enable the solution accelerator to add the device to the map.
  • A versão atual do firmware.The current firmware version.
  • A lista de métodos que o dispositivo suporta.The list of methods the device supports.
  • O esquema das mensagens de telemetria enviadas pelo dispositivo.The schema of the telemetry messages sent by the device.
typedef struct MESSAGESCHEMA_TAG
{
    char* name;
    char* format;
    char* fields;
} MessageSchema;

typedef struct TELEMETRYSCHEMA_TAG
{
    MessageSchema messageSchema;
} TelemetrySchema;

typedef struct TELEMETRYPROPERTIES_TAG
{
    TelemetrySchema temperatureSchema;
    TelemetrySchema humiditySchema;
    TelemetrySchema pressureSchema;
} TelemetryProperties;

typedef struct CHILLER_TAG
{
    // Reported properties
    char* protocol;
    char* supportedMethods;
    char* type;
    char* firmware;
    FIRMWARE_UPDATE_STATUS firmwareUpdateStatus;
    char* location;
    double latitude;
    double longitude;
    TelemetryProperties telemetry;

    // Manage firmware update process
    char* new_firmware_version;
    char* new_firmware_URI;
} Chiller;

A amostra inclui uma função serializeToJson que serializa esta estrutura de dados usando a biblioteca Parson.The sample includes a serializeToJson function that serializes this data structure using the Parson library.

A amostra inclui várias funções de retorno que imprimem informações para a consola à medida que o cliente interage com o acelerador de solução:The sample includes several callback functions that print information to the console as the client interacts with the solution accelerator:

  • connection_status_callbackconnection_status_callback
  • send_confirm_callbacksend_confirm_callback
  • reported_state_callbackreported_state_callback
  • device_method_callbackdevice_method_callback

O seguinte corte mostra a função device_method_callback.The following snippet shows the device_method_callback function. Esta função determina a ação a tomar quando uma chamada de método é recebida do acelerador de solução.This function determines the action to take when a method call is received from the solution accelerator. A função recebe uma referência à estrutura de dados Chiller no parâmetro userContextCallback.The function receives a reference to the Chiller data structure in the userContextCallback parameter. O valor do userContextCallback é definido quando a função de retorno é configurada na função principal:The value of userContextCallback is set when the callback function is configured in the main function:

static int device_method_callback(const char* method_name, const unsigned char* payload, size_t size, unsigned char** response, size_t* response_size, void* userContextCallback)
{
    Chiller *chiller = (Chiller *)userContextCallback;

    int result;

    (void)printf("Direct method name:    %s\r\n", method_name);

    (void)printf("Direct method payload: %.*s\r\n", (int)size, (const char*)payload);

    if (strcmp("Reboot", method_name) == 0)
    {
        MESSAGERESPONSE(201, "{ \"Response\": \"Rebooting\" }")
    }
    else if (strcmp("EmergencyValveRelease", method_name) == 0)
    {
        MESSAGERESPONSE(201, "{ \"Response\": \"Releasing emergency valve\" }")
    }
    else if (strcmp("IncreasePressure", method_name) == 0)
    {
        MESSAGERESPONSE(201, "{ \"Response\": \"Increasing pressure\" }")
    }
    else if (strcmp("FirmwareUpdate", method_name) == 0)
    {
        if (chiller->firmwareUpdateStatus != IDLE)
        {
            (void)printf("Attempt to invoke firmware update out of order\r\n");
            MESSAGERESPONSE(400, "{ \"Response\": \"Attempting to initiate a firmware update out of order\" }")
        }
        else
        {
            getFirmwareUpdateValues(chiller, payload);

            if (chiller->new_firmware_version != NULL && chiller->new_firmware_URI != NULL)
            {
                // Create a thread for the long-running firmware update process.
                THREAD_HANDLE thread_apply;
                THREADAPI_RESULT t_result = ThreadAPI_Create(&thread_apply, do_firmware_update, chiller);
                if (t_result == THREADAPI_OK)
                {
                    (void)printf("Starting firmware update thread\r\n");
                    MESSAGERESPONSE(201, "{ \"Response\": \"Starting firmware update thread\" }")
                }
                else
                {
                    (void)printf("Failed to start firmware update thread\r\n");
                    MESSAGERESPONSE(500, "{ \"Response\": \"Failed to start firmware update thread\" }")
                }
            }
            else
            {
                (void)printf("Invalid method payload\r\n");
                MESSAGERESPONSE(400, "{ \"Response\": \"Invalid payload\" }")
            }
        }
    }
    else
    {
        // All other entries are ignored.
        (void)printf("Method not recognized\r\n");
        MESSAGERESPONSE(400, "{ \"Response\": \"Method not recognized\" }")
    }

    return result;
}

Quando o acelerador de solução chama o método de atualização do firmware, a amostra deseriza a carga útil JSON e inicia um fio de fundo para completar o processo de atualização.When the solution accelerator calls the firmware update method, the sample deserializes the JSON payload and starts a background thread to complete the update process. O seguinte corte mostra o do_firmware_update que corre no fio:The following snippet shows the do_firmware_update that runs on the thread:

/*
 This is a thread allocated to process a long-running device method call.
 It uses device twin reported properties to communicate status values
 to the Remote Monitoring solution accelerator.
*/
static int do_firmware_update(void *param)
{
    Chiller *chiller = (Chiller *)param;
    printf("Running simulated firmware update: URI: %s, Version: %s\r\n", chiller->new_firmware_URI, chiller->new_firmware_version);

    printf("Simulating download phase...\r\n");
    chiller->firmwareUpdateStatus = DOWNLOADING;
    sendChillerReportedProperties(chiller);

    ThreadAPI_Sleep(5000);

    printf("Simulating apply phase...\r\n");
    chiller->firmwareUpdateStatus = APPLYING;
    sendChillerReportedProperties(chiller);

    ThreadAPI_Sleep(5000);

    printf("Simulating reboot phase...\r\n");
    chiller->firmwareUpdateStatus = REBOOTING;
    sendChillerReportedProperties(chiller);

    ThreadAPI_Sleep(5000);

    size_t size = strlen(chiller->new_firmware_version) + 1;
    (void)memcpy(chiller->firmware, chiller->new_firmware_version, size);

    chiller->firmwareUpdateStatus = IDLE;
    sendChillerReportedProperties(chiller);

    return 0;
}

O seguinte corte mostra como o cliente envia uma mensagem de telemetria para o acelerador de solução.The following snippet shows how the client sends a telemetry message to the solution accelerator. As propriedades da mensagem incluem o esquema de mensagem para ajudar o acelerador de solução a exibir a telemetria no painel de instrumentos:The message properties include the message schema to help the solution accelerator display the telemetry on the dashboard:

static void send_message(IOTHUB_DEVICE_CLIENT_HANDLE handle, char* message, char* schema)
{
    IOTHUB_MESSAGE_HANDLE message_handle = IoTHubMessage_CreateFromString(message);

    // Set system properties
    (void)IoTHubMessage_SetMessageId(message_handle, "MSG_ID");
    (void)IoTHubMessage_SetCorrelationId(message_handle, "CORE_ID");
    (void)IoTHubMessage_SetContentTypeSystemProperty(message_handle, "application%2fjson");
    (void)IoTHubMessage_SetContentEncodingSystemProperty(message_handle, "utf-8");

    // Set application properties
    MAP_HANDLE propMap = IoTHubMessage_Properties(message_handle);
    (void)Map_AddOrUpdate(propMap, "$$MessageSchema", schema);
    (void)Map_AddOrUpdate(propMap, "$$ContentType", "JSON");

    time_t now = time(0);
    struct tm* timeinfo;
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable: 4996) /* Suppress warning about possible unsafe function in Visual Studio */
#endif
    timeinfo = gmtime(&now);
#ifdef _MSC_VER
#pragma warning(pop)
#endif
    char timebuff[50];
    strftime(timebuff, 50, "%Y-%m-%dT%H:%M:%SZ", timeinfo);
    (void)Map_AddOrUpdate(propMap, "$$CreationTimeUtc", timebuff);

    IoTHubDeviceClient_SendEventAsync(handle, message_handle, send_confirm_callback, NULL);

    IoTHubMessage_Destroy(message_handle);
}

A função principal da amostra:The main function in the sample:

  • Inicializa e desliga o subsistema SDK.Initializes and shuts down the SDK subsystem.
  • Inicializa a estrutura de dados Chiller.Initializes the Chiller data structure.
  • Envia as propriedades reportadas para o acelerador de solução.Sends the reported properties to the solution accelerator.
  • Configura a função de retorno do método do dispositivo.Configures the device method callback function.
  • Envia valores de telemetria simulados para o acelerador de solução.Sends simulated telemetry values to the solution accelerator.
int main(void)
{
    srand((unsigned int)time(NULL));
    double minTemperature = 50.0;
    double minPressure = 55.0;
    double minHumidity = 30.0;
    double temperature = 0;
    double pressure = 0;
    double humidity = 0;

    (void)printf("This sample simulates a Chiller device connected to the Remote Monitoring solution accelerator\r\n\r\n");

    // Used to initialize sdk subsystem
    (void)IoTHub_Init();

    (void)printf("Creating IoTHub handle\r\n");
    // Create the iothub handle here
    device_handle = IoTHubDeviceClient_CreateFromConnectionString(connectionString, MQTT_Protocol);
    if (device_handle == NULL)
    {
        (void)printf("Failure creating IotHub device. Hint: Check your connection string.\r\n");
    }
    else
    {
        // Setting connection status callback to get indication of connection to iothub
        (void)IoTHubDeviceClient_SetConnectionStatusCallback(device_handle, connection_status_callback, NULL);

        Chiller chiller;
        memset(&chiller, 0, sizeof(Chiller));
        chiller.protocol = "MQTT";
        chiller.supportedMethods = "Reboot,FirmwareUpdate,EmergencyValveRelease,IncreasePressure";
        chiller.type = "Chiller";
        size_t size = strlen(initialFirmwareVersion) + 1;
        chiller.firmware = malloc(size);
        if (chiller.firmware == NULL)
        {
            (void)printf("Chiller Firmware failed to allocate memory.\r\n");
        }
        else
        {
            memcpy(chiller.firmware, initialFirmwareVersion, size);
            chiller.firmwareUpdateStatus = IDLE;
            chiller.location = "Building 44";
            chiller.latitude = 47.638928;
            chiller.longitude = -122.13476;
            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.messageSchema.name = "chiller-humidity;v1";
            chiller.telemetry.humiditySchema.messageSchema.format = "JSON";
            chiller.telemetry.humiditySchema.messageSchema.fields = "{\"humidity\":\"Double\",\"humidity_unit\":\"Text\"}";
            chiller.telemetry.pressureSchema.messageSchema.name = "chiller-pressure;v1";
            chiller.telemetry.pressureSchema.messageSchema.format = "JSON";
            chiller.telemetry.pressureSchema.messageSchema.fields = "{\"pressure\":\"Double\",\"pressure_unit\":\"Text\"}";

            sendChillerReportedProperties(&chiller);

            (void)IoTHubDeviceClient_SetDeviceMethodCallback(device_handle, device_method_callback, &chiller);

            while (1)
            {
                temperature = minTemperature + ((rand() % 10) + 5);
                pressure = minPressure + ((rand() % 10) + 5);
                humidity = minHumidity + ((rand() % 20) + 5);

                if (chiller.firmwareUpdateStatus == IDLE)
                {
                    (void)printf("Sending sensor value Temperature = %f %s,\r\n", temperature, "F");
                    (void)sprintf_s(msgText, sizeof(msgText), "{\"temperature\":%.2f,\"temperature_unit\":\"F\"}", temperature);
                    send_message(device_handle, msgText, chiller.telemetry.temperatureSchema.messageSchema.name);


                    (void)printf("Sending sensor value Pressure = %f %s,\r\n", pressure, "psig");
                    (void)sprintf_s(msgText, sizeof(msgText), "{\"pressure\":%.2f,\"pressure_unit\":\"psig\"}", pressure);
                    send_message(device_handle, msgText, chiller.telemetry.pressureSchema.messageSchema.name);


                    (void)printf("Sending sensor value Humidity = %f %s,\r\n", humidity, "%");
                    (void)sprintf_s(msgText, sizeof(msgText), "{\"humidity\":%.2f,\"humidity_unit\":\"%%\"}", humidity);
                    send_message(device_handle, msgText, chiller.telemetry.humiditySchema.messageSchema.name);
                }

                ThreadAPI_Sleep(5000);
            }

            (void)printf("\r\nShutting down\r\n");

            // Clean up the iothub sdk handle and free resources
            IoTHubDeviceClient_Destroy(device_handle);
            free(chiller.firmware);
            free(chiller.new_firmware_URI);
            free(chiller.new_firmware_version);
        }
    }
    // Shutdown the sdk subsystem
    IoTHub_Deinit();

    return 0;
}

Compilar e executar a aplicaçãoBuild and run the application

Os passos seguintes descrevem como usar o CMake para construir a aplicação do cliente.The following steps describe how to use CMake to build the client application. A aplicação do cliente de monitorização remota é construída como parte do processo de construção do SDK.The remote monitoring client application is built as part of the build process for the SDK.

  1. Edite o ficheiro remote_monitoring.c para substituir <connectionstring> pela cadeia de ligação do dispositivo que observou no início deste guia quando adicionou um dispositivo ao acelerador de solução.Edit the remote_monitoring.c file to replace <connectionstring> with the device connection string you noted at the start of this how-to guide when you added a device to the solution accelerator.

  2. Navegue até à raiz da sua cópia clonada do repositório de repositório Azure IoT C SDKs e execute os seguintes comandos para construir a aplicação do cliente:Navigate to root of your cloned copy of the Azure IoT C SDKs repository repository and run the following commands to build the client application:

    mkdir cmake
    cd cmake
    cmake ../
    make
    
  3. Executar a aplicação do cliente e enviar telemetria para ioT Hub:Run the client application and send telemetry to IoT Hub:

    ./samples/solutions/remote_monitoring_client/remote_monitoring_client
    

    A consola apresenta mensagens como:The console displays messages as:

    • A aplicação envia telemetria de amostra para o acelerador de solução.The application sends sample telemetry to the solution accelerator.
    • Responde aos métodos invocados do painel de instrumentos de solução.Responds to methods invoked from the solution dashboard.

Ver a telemetria do dispositivoView device telemetry

Pode ver a telemetria enviada do seu dispositivo na página Device Explorer na solução.You can view the telemetry sent from your device on the Device Explorer page in the solution.

  1. Selecione o dispositivo que forvisionou na lista de dispositivos na página Device Explorer.Select the device you provisioned in the list of devices on the Device Explorer page. Um painel apresenta informações sobre o seu dispositivo, incluindo um enredo da telemetria do dispositivo:A panel displays information about your device including a plot of the device telemetry:

    Ver detalhes do dispositivo

  2. Escolha a pressão para alterar o visor da telemetria:Choose Pressure to change the telemetry display:

    Ver telemetria de pressão

  3. Para visualizar informações de diagnóstico sobre o seu dispositivo, desloque-se até ao Diagnóstico:To view diagnostic information about your device, scroll down to Diagnostics:

    Ver diagnósticos do dispositivo

Agir no seu dispositivoAct on your device

Para invocar métodos nos seus dispositivos, utilize a página Explorer do Dispositivo na solução de Monitorização Remota.To invoke methods on your devices, use the Device Explorer page in the Remote Monitoring solution. Por exemplo, na solução de monitorização remota, os dispositivos Chiller implementam um método reboot.For example, in the Remote Monitoring solution Chiller devices implement a Reboot method.

  1. Escolha dispositivos para navegar na página device Explorer na solução.Choose Devices to navigate to the Device Explorer page in the solution.

  2. Selecione o dispositivo que alistou na lista de dispositivos na página Device Explorer:Select the device you provisioned in the list of devices on the Device Explorer page:

    Selecione o seu verdadeiro dispositivo

  3. Para apresentar uma lista dos métodos que pode recorrer no seu dispositivo, escolha Jobs, em seguida, Métodos.To display a list of the methods you can call on your device, choose Jobs, then Methods. Para agendar um trabalho para executar em vários dispositivos, pode selecionar vários dispositivos na lista.To schedule a job to run on multiple devices, you can select multiple devices in the list. O painel Jobs mostra os tipos de método comum a todos os dispositivos selecionados.The Jobs panel shows the types of method common to all the devices you selected.

  4. Escolha o Reboot, despe um pouco o nome de trabalho para RebootPhysicalChiller e, em seguida, escolha Aplicar:Choose Reboot, set the job name to RebootPhysicalChiller and then choose Apply:

    Agende a atualização do firmware

  5. Uma sequência de mensagens aparece na consola a executar o código do dispositivo enquanto o dispositivo simulado trata do método.A sequence of messages displays in the console running your device code while the simulated device handles the method.

Nota

Para acompanhar o estado do trabalho na solução, escolha Ver Situação do Trabalho.To track the status of the job in the solution, choose View Job Status.

Próximos passosNext steps

O artigo Personalize o acelerador de solução de monitorização remota descreve algumas formas de personalizar o acelerador de solução.The article Customize the Remote Monitoring solution accelerator describes some ways to customize the solution accelerator.