Conectar seu dispositivo Raspberry Pi ao acelerador da solução de monitoramento remoto (C)Connect your Raspberry Pi device to the Remote Monitoring solution accelerator (C)

Neste tutorial, você implementa um dispositivo Chiller que envia a seguinte telemetria para o acelerador de soluçõesde monitoramento remoto :In this tutorial, you implement a Chiller device that sends the following telemetry to the Remote Monitoring solution accelerator:

  • TemperaturaTemperature
  • PressãoPressure
  • UmidadeHumidity

Para simplificar, o código gera valores de telemetria de exemplo para o Resfriador.For simplicity, the code generates sample telemetry values for the Chiller. Você pode estender o exemplo conectando sensores reais ao dispositivo e enviando telemetria real.You could extend the sample by connecting real sensors to your device and sending real telemetry.

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

  • Envia os metadados à solução para descrever seus recursos.Sends metadata to the solution to describe its capabilities.
  • Responde às ações disparadas 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 da página Dispositivos na solução.Responds to configuration changes send from the Devices page in the solution.

Para concluir este tutorial, você precisa de uma conta ativa do Azure.To complete this tutorial, you need an active Azure account. Se não tiver uma conta, você poderá criar uma conta 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 detalhes, consulte Azure Free Trial.For details, see Azure Free Trial.

Antes de começarBefore you start

Antes de escrever qualquer código para o dispositivo, implante o acelerador de solução de Monitoramento Remoto 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.

Implantar o acelerador de solução de Monitoramento RemotoDeploy your Remote Monitoring solution accelerator

O dispositivo Chiller que você cria neste tutorial envia dados para uma instância do acelerador de soluções de monitoramento remoto.The Chiller device you create in this tutorial sends data to an instance of the Remote Monitoring solution accelerator. Se você ainda não provisionou o acelerador de soluções de monitoramento remoto em sua conta Do Azure, consulte Implantar o acelerador de soluções de monitoramento remotoIf 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 implantação da solução de monitoramento remoto terminar, clique em Iniciar para abrir o painel 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 da solução

Adicionar o dispositivo à solução de Monitoramento RemotoAdd your device to the Remote Monitoring solution

Observação

Se você já adicionou um dispositivo em sua solução, poderá ignorar esta etapa.If you have already added a device in your solution, you can skip this step. No entanto, a próxima etapa exige a cadeia de conexão do dispositivo.However, the next step requires your device connection string. É possível recuperar a cadeia de conexão de um dispositivo a partir do Portal do Azure ou usando uma ferramente da CLI az iot.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, ele precisa se identificar para o Hub IoT usando credenciais válidas.For a device to connect to the solution accelerator, it must identify itself to IoT Hub using valid credentials. É possível salvar a cadeia de conexão do dispositivo contendo essas credenciais, quando você adicionar 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. Você incluirá a cadeia de conexão de dispositivo no seu aplicativo cliente, mais adiante neste tutorial.You include the device connection string in your client application later in this tutorial.

Para adicionar um dispositivo à sua solução de monitoramento remoto, complete as seguintes etapas na página do Explorador de dispositivos 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 dispositivoe escolha Real como o tipo de dispositivo:Choose + New device, and then choose Real as the Device type:

    Adicionar um dispositivo real

  2. Insira Physical-chiller como a ID do dispositivo.Enter Physical-chiller as the Device ID. Escolha as opções Chave Simétrica e Gerar chaves automaticamente:Choose the Symmetric Key and Auto generate keys options:

    Escolher as opções do dispositivo

  3. Escolha Aplicar.Choose Apply. Em seguida, anote os valores ID do dispositivo, Chave Primária e Cadeia de conexão – Chave primária:Then make a note of the Device ID, Primary Key, and Connection string primary key values:

    Recuperar credenciais

Agora, você adicionou um dispositivo real ao acelerador de solução de Monitoramento Remoto e anotou a cadeia de conexão do dispositivo.You've now added a real device to the Remote Monitoring solution accelerator and noted its device connection string. Nas seções a seguir, você implementará o aplicativo cliente que usa a cadeia de conexão do dispositivo para conectar-se à solução.In the following sections, you implement the client application that uses the device connection string to connect to your solution.

O aplicativo cliente implementa o modelo de dispositivo Resfriador interno.The client application implements the built-in Chiller device model. Um modelo de dispositivo de 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 relata à solução.The properties the device reports to the solution. Por exemplo, um dispositivo Resfriador relata informações sobre seu firmware e sua 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 Resfriador envia valores de temperatura, umidade e pressão.For example, a Chiller device sends temperature, humidity, and pressure values.
  • Os métodos que você pode agendar na solução para serem executados no dispositivo.The methods you can schedule from the solution to run on the device. Por exemplo, um dispositivo Resfriador deve implementar os métodos Reiniciar, FirmwareUpdate, EmergencyValveRelease e IncreasePressure.For example, a Chiller device must implement Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressure methods.

Este tutorial mostra como conectar um dispositivo real ao acelerador de solução de Monitoramento Remoto.This tutorial shows you how to connect a real device to the Remote Monitoring solution accelerator. Assim como acontece com a maioria dos aplicativos inseridos que são executados em dispositivos restritos, o código do cliente do aplicativo do dispositivo Raspberry Pi é escrito em C. Neste tutorial, você cria o aplicativo em um Raspberry Pi executando o sistema operacional Raspbian.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 você 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.

Requisitos de hardwareRequired hardware

Um computador desktop para que você possa se conectar remotamente à linha de comando no Raspberry Pi.A desktop computer to enable you to connect remotely to the command line on the Raspberry Pi.

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

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

Software de área de trabalho necessárioRequired desktop software

É necessário um cliente SSH em seu computador desktop para que você possa acessar remotamente a linha de comando no 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 o uso de PuTTY.We recommend using PuTTY.
  • A maioria das distribuições do Linux e Mac OS incluem o utilitário de linha de comando do SSH.Most Linux distributions and Mac OS include the command-line SSH utility. Para obter mais informações, consulte SSH usando o Linux ou Mac OS.For more information, see SSH Using Linux or Mac OS.

Software do Raspberry Pi necessárioRequired Raspberry Pi software

Este artigo pressupõe que você tenha instalado a versão mais recente do Raspbian SO em seu Raspberry Pi.This article assumes you have installed the latest version of the Raspbian OS on your Raspberry Pi.

As etapas a seguir mostram como preparar seu Raspberry Pi para criar um aplicativo 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. Conecte-se ao seu Raspberry Pi usando ssh.Connect to your Raspberry Pi using ssh. Para obter mais informações, consulte SSH (Secure Shell) no site do Raspberry Pi.For more information, see SSH (Secure Shell) on the Raspberry Pi website.

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

    sudo apt-get update
    
  3. Para concluir as etapas neste guia de instruções, siga as etapas em configurar o ambiente de desenvolvimento Linux para adicionar as bibliotecas e ferramentas de desenvolvimento necessárias para o 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.

Exibir o códigoView the code

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

Baixar o código-fonte e preparar o projetoDownload the source code and prepare the project

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

O exemplo está localizado na pasta samples/solutions/remote_monitoring_client.The sample is located in the samples/solutions/remote_monitoring_client folder.

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

Passo a passo do códigoCode walkthrough

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

O snippet a seguir mostra como as propriedades relatadas que descrevem os recursos do dispositivo são definidas.The following snippet shows how the reported properties that describe the capabilities of the device are defined. Essas 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 com suporte no dispositivo.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;

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

O exemplo inclui várias funções de retorno de chamada que imprimem informações no console enquanto 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 snippet a seguir mostra a função device_method_callback.The following snippet shows the device_method_callback function. Essa função determina a ação a ser tomada 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 para a estrutura de dados do Resfriador no parâmetro userContextCallback.The function receives a reference to the Chiller data structure in the userContextCallback parameter. O valor de userContextCallback é definido quando a função de retorno de chamada é 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 de firmware, o exemplo desserializa a carga JSON e inicia um thread de segundo plano para concluir 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 snippet a seguir mostra o do_firmware_update que executa no thread: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 snippet a seguir mostra como o cliente envia uma mensagem de telemetria ao 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: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 no exemplo:The main function in the sample:

  • Inicializa e desliga o subsistema SDK.Initializes and shuts down the SDK subsystem.
  • Inicializa a estrutura de dados do Resfriador.Initializes the Chiller data structure.
  • Envia as propriedades relatadas ao acelerador de solução.Sends the reported properties to the solution accelerator.
  • Configura a função de retorno de chamada do método do dispositivo.Configures the device method callback function.
  • Envia valores de telemetria simulados ao 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 you 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);
        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;
}

Compile e execute o aplicativoBuild and run the application

As etapas a seguir descrevem como usar CMake para compilar o aplicativo cliente.The following steps describe how to use CMake to build the client application. O aplicativo cliente de monitoramento remoto foi criado como parte do processo de build para o SDK.The remote monitoring client application is built as part of the build process for the SDK.

  1. Edite o arquivo remote_monitoring para substituir <connectionstring> pela cadeia de conexão do dispositivo que você anotou no início deste guia de instruções, quando adicionou um dispositivo do 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é a raiz da sua cópia clonada do repositório de SDKs C do IoT do Azure e execute os seguintes comandos para compilar o aplicativo 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. Execute o aplicativo cliente e envie telemetria ao Hub IoT:Run the client application and send telemetry to IoT Hub:

    ./samples/solutions/remote_monitoring_client/remote_monitoring_client
    

    O console exibe mensagens, como:The console displays messages as:

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

Exibir telemetria de dispositivoView device telemetry

Você pode visualizar a telemetria enviada do seu dispositivo na página Do Explorador de dispositivos 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 você provisionou na lista de dispositivos na página Do Explorador de dispositivos.Select the device you provisioned in the list of devices on the Device Explorer page. Um painel exibe informações sobre seu dispositivo, incluindo um gráfico de telemetria do dispositivo:A panel displays information about your device including a plot of the device telemetry:

    Consultar detalhes do dispositivo

  2. Escolha Pressão para alterar a exibição de telemetria:Choose Pressure to change the telemetry display:

    Exibir telemetria de pressão

  3. Para exibir informações de diagnóstico sobre o dispositivo, role para baixo até Diagnóstico:To view diagnostic information about your device, scroll down to Diagnostics:

    Exibir diagnóstico do dispositivo

Agir no dispositivoAct on your device

Para invocar métodos em seus dispositivos, use a página Explorador de dispositivos na solução de Monitoramento Remoto.To invoke methods on your devices, use the Device Explorer page in the Remote Monitoring solution. Por exemplo, na solução de monitoramento remoto, os dispositivos Chiller implementam um método de reinicialização.For example, in the Remote Monitoring solution Chiller devices implement a Reboot method.

  1. Escolha dispositivos para navegar até a página Do Explorador de dispositivos na solução.Choose Devices to navigate to the Device Explorer page in the solution.

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

    Selecione seu dispositivo real

  3. Para exibir uma lista dos métodos que você pode chamar em seu dispositivo, escolha Empregos, em seguida, Métodos.To display a list of the methods you can call on your device, choose Jobs, then Methods. Para agendar um método a ser executado em vários dispositivos, você 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 Trabalhos mostra os tipos de método comuns a todos os dispositivos selecionados.The Jobs panel shows the types of method common to all the devices you selected.

  4. Escolha Reinicializar, definir o nome do trabalho como RebootPhysicalChiller e, em seguida, escolher Aplicar:Choose Reboot, set the job name to RebootPhysicalChiller and then choose Apply:

    Agendar a atualização do firmware

  5. Uma sequência de mensagens é exibida no console executando o código de dispositivo, enquanto o dispositivo simulado manipula o método.A sequence of messages displays in the console running your device code while the simulated device handles the method.

Observação

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

Próximas etapasNext steps

O artigo Personalizar o acelerador de soluções de monitoramento remoto descreve algumas maneiras de personalizar o acelerador de soluções.The article Customize the Remote Monitoring solution accelerator describes some ways to customize the solution accelerator.