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

Neste tutorial, implementar um Chiller dispositivo que envia a seguinte telemetria para a monitorização remota acelerador de solução: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 exemplo para o Chiller.For simplicity, the code generates sample telemetry values for the Chiller. Pode alargar a amostra ao ligar sensores reais ao dispositivo e enviar 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 para a solução para descrever seus recursos.Sends metadata to the solution to describe its capabilities.
  • Responde às ações acionadas a partir da dispositivos página na solução.Responds to actions triggered from the Devices page in the solution.
  • Enviar responde às alterações de configuração a partir da dispositivos página 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, implementar o acelerador de soluções 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.

Implementar o acelerador de soluções de monitorização remotaDeploy your Remote Monitoring solution accelerator

O Chiller dispositivo que vai criar neste tutorial envia dados para uma instância da monitorização remota acelerador de solução.The Chiller device you create in this tutorial sends data to an instance of the Remote Monitoring solution accelerator. Se ainda não aprovisionou o acelerador de solução de monitorização remota na sua conta do Azure, veja 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 concluir o processo de implantação para a solução de monitorização remota, clique em inicie para abrir o dashboard de solução no seu browser.When the deployment process for the Remote Monitoring solution finishes, click Launch to open the solution dashboard in your browser.

O dashboard da solução

Adicionar o seu dispositivo à solução de monitorização remotaAdd your device to the Remote Monitoring solution

Nota

Se já tiver adicionado um dispositivo na sua solução, pode ignorar este passo.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 ligação do dispositivo.However, the next step requires your device connection string. Pode recuperar a cadeia de ligação de um dispositivo do portal do Azure ou utilizando o az iot ferramenta CLI.You can retrieve a device's connection string from the Azure portal or using the az iot CLI tool.

Para um dispositivo para ligar ao solution accelerator, ele tem de se identificar no IoT Hub com credenciais válidas.For a device to connect to the solution accelerator, it must identify itself to IoT Hub using valid credentials. Terá a oportunidade para guardar a cadeia de ligação do dispositivo que contém essas credenciais ao 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. Incluir a cadeia de ligação do dispositivo na sua aplicação 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, execute os seguintes passos no Device Explorer página 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. Escolher + novo dispositivoe, em seguida, escolha Real como o tipo de dispositivo:Choose + New device, and then choose Real as the Device type:

    Adicionar um dispositivo real

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

    Escolher opções de dispositivo

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

    Obter credenciais

Acabou de adicionar um dispositivo real para o acelerador de solução de monitorização remota e observar 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 seções a seguir, implementa a aplicação de cliente que utiliza a cadeia de ligação do dispositivo para 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 cliente implementa o incorporado Chiller modelo do dispositivo.The client application implements the built-in Chiller device model. Um modelo de dispositivo do 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 comunica à solução.The properties the device reports to the solution. Por exemplo, um Chiller dispositivo comunica informações sobre o respetivo 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 Chiller dispositivo envia a temperatura, humidade e valores de pressão.For example, a Chiller device sends temperature, humidity, and pressure values.
  • Os métodos pode agendar da solução para executar no dispositivo.The methods you can schedule from the solution to run on the device. Por exemplo, um Chiller dispositivo tem de implementar reiniciar, FirmwareUpdate, EmergencyValveRelease, e IncreasePressure métodos.For example, a Chiller device must implement Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressure methods.

Este tutorial mostra-lhe como ligar um dispositivo real para o 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 aplicativos mais incorporados que são executadas em dispositivos restritos, o código de cliente para a aplicação de dispositivo Raspberry Pi é escrito em C. Neste tutorial, vai criar o aplicativo num Raspberry Pi a executar o SO 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 preferir simular um dispositivo, veja criar e teste de 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 comandos 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 utiliza 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 ambiente de trabalho necessáriasRequired desktop software

Terá de cliente SSH no seu computador desktop que lhe permite aceder remotamente a linha de comandos no Raspberry Pi.You need SSH client on your desktop machine to enable you to remotely access the command line on the Raspberry Pi.

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

Software necessário de Raspberry PiRequired Raspberry Pi software

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

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

  1. Ligar ao seu Raspberry Pi com ssh.Connect to your Raspberry Pi using ssh. Para obter mais informações, consulte SSH (Secure Shell) sobre o 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 concluir os passos neste guia de procedimentos siga os passos em configurar o ambiente de desenvolvimento do Linux para adicionar as ferramentas de desenvolvimento necessárias e bibliotecas para o 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 exemplo utilizados neste guia está disponível no repositório do GitHub de SDKs do Azure IoT C.The sample code used in this guide is available in the Azure IoT C SDKs GitHub repository.

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

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

O exemplo está localizado no amostras/soluções/remote_monitoring_client pasta.The sample is located in the samples/solutions/remote_monitoring_client folder.

Abra o remote_monitoring.c de ficheiros a exemplos/soluções/remote_monitoring_client pasta num editor de texto.Open the remote_monitoring.c file in the samples/solutions/remote_monitoring_client folder in a text editor.

Código passo a passoCode walkthrough

Esta secção descreve algumas das principais partes do código de exemplo e explica como se relacionam 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 fragmento seguinte mostra como as propriedades reportadas 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. Essas propriedades incluem:These properties include:

  • A localização do dispositivo para ativar o solution accelerator adicionar o dispositivo ao mapa.The location of the device to enable the solution accelerator to add the device to the map.
  • A versão de firmware atual.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 enviada 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 um serializeToJson função que serializa essa estrutura de dados usando a biblioteca de 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 para a consola à medida que o cliente interage com o solution accelerator: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 fragmento seguinte mostra os device_method_callback função.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 a partir do solution accelerator.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 o Chiller estrutura de dados no userContextCallback parâmetro.The function receives a reference to the Chiller data structure in the userContextCallback parameter. O valor de userContextCallback é definida quando a função de retorno de chamada é configurada no principal função: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 solution accelerator chama o método de atualização de firmware, o exemplo desserializa o payload JSON e inicia um thread em 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 fragmento seguinte mostra os do_firmware_update que é executado 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 fragmento seguinte mostra como o cliente envia uma mensagem de telemetria para o solution accelerator.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 solution accelerator apresentar a telemetria no dashboard: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);
}

O principal função no exemplo:The main function in the sample:

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

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

Os passos seguintes descrevem como utilizar CMake para criar a aplicação de cliente.The following steps describe how to use CMake to build the client application. A aplicação de cliente de monitorização remota foi desenvolvida como parte do processo de compilação para o SDK.The remote monitoring client application is built as part of the build process for the SDK.

  1. Editar a remote_monitoring.c ficheiro para substituir o <connectionstring> com a cadeia de ligação do dispositivo que anotou no início deste guia de procedimentos quando adicionou um dispositivo para o solution accelerator.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 para a raiz da sua cópia clonada a repositório Azure IoT SDKs de C repositório e execute os seguintes comandos para criar a aplicação de 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 a aplicação de cliente e enviar telemetria ao IoT Hub:Run the client application and send telemetry to IoT Hub:

    ./samples/solutions/remote_monitoring_client/remote_monitoring_client
    

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

    • A aplicação envia telemetria de exemplo para o solution accelerator.The application sends sample telemetry to the solution accelerator.
    • Responde a métodos invocados a partir do dashboard da solução.Responds to methods invoked from the solution dashboard.

Ver a telemetria do dispositivoView device telemetry

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

  1. Selecione o dispositivo aprovisionado na lista de dispositivos no Device Explorer página.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 desenho de telemetria do dispositivo:A panel displays information about your device including a plot of the device telemetry:

    Ver detalhes do dispositivo

  2. Escolher pressão para alterar a apresentação de telemetria:Choose Pressure to change the telemetry display:

    Ver a telemetria de pressão

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

    Diagnóstico de dispositivos do Vista

Agir em seu dispositivoAct on your device

Para invocar métodos nos seus dispositivos, utilize o Device Explorer página 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 Chiller dispositivos implementam um reiniciar método.For example, in the Remote Monitoring solution Chiller devices implement a Reboot method.

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

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

    Selecione o seu dispositivo real

  3. Para apresentar uma lista dos métodos que pode chamar no seu dispositivo, escolha trabalhos, em seguida, métodos.To display a list of the methods you can call on your device, choose Jobs, then Methods. Para agendar uma tarefa para ser executada 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 tarefas painel mostra os tipos de método comuns a todos os dispositivos que selecionou.The Jobs panel shows the types of method common to all the devices you selected.

  4. Escolher reinicie, defina o nome da tarefa como RebootPhysicalChiller e, em seguida, escolha aplicar:Choose Reboot, set the job name to RebootPhysicalChiller and then choose Apply:

    Agendar a atualização de firmware

  5. Apresenta uma sequência de mensagens na consola de execução do seu código de dispositivo enquanto o dispositivo simulado lida com o método.A sequence of messages displays in the console running your device code while the simulated device handles the method.

Nota

Para controlar o estado da tarefa na solução, escolha ver o estado de tarefa.To track the status of the job in the solution, choose View Job Status.

Passos SeguintesNext steps

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