Připojení zařízení malinu pi k akcelerátoru řešení vzdáleného monitorování (C)Connect your Raspberry Pi device to the Remote Monitoring solution accelerator (C)

V tomto kurzu implementujete chladicí zařízení, které pošle následující telemetrii do akcelerátoru řešenívzdáleného monitorování:In this tutorial, you implement a Chiller device that sends the following telemetry to the Remote Monitoring solution accelerator:

  • TeplotaTemperature
  • CitlivostPressure
  • VlhkostHumidity

Pro zjednodušení kód generuje ukázkové hodnoty telemetrie pro chlazení.For simplicity, the code generates sample telemetry values for the Chiller. Ukázku můžete roztáhnout připojením skutečných senzorů k vašemu zařízení a odesláním skutečné telemetrie.You could extend the sample by connecting real sensors to your device and sending real telemetry.

Ukázkové zařízení také:The sample device also:

  • Odešle metadata do řešení, aby bylo možné popsat jeho schopnosti.Sends metadata to the solution to describe its capabilities.
  • Reaguje na akce aktivované na stránce zařízení v řešení.Responds to actions triggered from the Devices page in the solution.
  • Reaguje na změny konfigurace odesílané ze stránky zařízení v řešení.Responds to configuration changes send from the Devices page in the solution.

K dokončení tohoto kurzu potřebujete mít aktivní účet Azure.To complete this tutorial, you need an active Azure account. Pokud účet nemáte, můžete si během několika minut vytvořit bezplatný zkušební účet.If you don't have an account, you can create a free trial account in just a couple of minutes. Podrobnosti najdete v článku Bezplatná zkušební verze Azure.For details, see Azure Free Trial.

Než začneteBefore you start

Než napíšete kód pro vaše zařízení, nasaďte akcelerátor řešení vzdáleného monitorování a přidejte do řešení nové reálné zařízení.Before you write any code for your device, deploy your Remote Monitoring solution accelerator and add a new real device to the solution.

Nasazení akcelerátoru řešení vzdáleného monitorováníDeploy your Remote Monitoring solution accelerator

Chladicí zařízení, které v tomto kurzu vytvoříte, odesílá data do instance akcelerátoru řešení vzdáleného monitorování .The Chiller device you create in this tutorial sends data to an instance of the Remote Monitoring solution accelerator. Pokud jste ve svém účtu Azure ještě nezřídili akcelerátor řešení vzdáleného monitorování, přečtěte si téma nasazení akcelerátoru řešení vzdáleného monitorování .If you haven't already provisioned the Remote Monitoring solution accelerator in your Azure account, see Deploy the Remote Monitoring solution accelerator

Po dokončení procesu nasazení pro řešení vzdáleného monitorování kliknutím na Spustit otevřete řídicí panel řešení v prohlížeči.When the deployment process for the Remote Monitoring solution finishes, click Launch to open the solution dashboard in your browser.

Řídicí panel řešení

Přidání zařízení do řešení vzdáleného monitorováníAdd your device to the Remote Monitoring solution

Poznámka

Pokud jste už zařízení ve svém řešení přidali, můžete tento krok přeskočit.If you have already added a device in your solution, you can skip this step. Další krok ale vyžaduje připojovací řetězec zařízení.However, the next step requires your device connection string. Připojovací řetězec zařízení můžete načíst z Azure Portal nebo pomocí nástroje AZ IoT CLI.You can retrieve a device's connection string from the Azure portal or using the az iot CLI tool.

Aby se zařízení mohlo připojit k akcelerátoru řešení, musí identifikovat sebe, aby IoT Hub s použitím platných přihlašovacích údajů.For a device to connect to the solution accelerator, it must identify itself to IoT Hub using valid credentials. Po přidání zařízení do řešení máte možnost Uložit připojovací řetězec zařízení, který tyto přihlašovací údaje obsahuje.You have the opportunity to save the device connection string that contains these credentials when you add the device to the solution. Připojovací řetězec zařízení zahrnete do klientské aplikace dále v tomto kurzu.You include the device connection string in your client application later in this tutorial.

Pokud chcete přidat zařízení do řešení vzdáleného monitorování, na stránce Device Explorer v řešení proveďte následující kroky:To add a device to your Remote Monitoring solution, complete the following steps on the Device Explorer page in the solution:

  1. Zvolte + nové zařízenía pak jako typ zařízenízvolte reálné :Choose + New device, and then choose Real as the Device type:

    Přidání skutečného zařízení

  2. Jako ID zařízení zadejte fyzický-chladicí zařízení.Enter Physical-chiller as the Device ID. Vyberte možnosti symetrického klíče a Automatické generování klíčů :Choose the Symmetric Key and Auto generate keys options:

    Zvolit možnosti zařízení

  3. Zvolte Použít.Choose Apply. Pak si poznamenejte hodnoty primárního klíče pro ID zařízení, primární klíča připojovací řetězec :Then make a note of the Device ID, Primary Key, and Connection string primary key values:

    Načíst přihlašovací údaje

Nyní jste přidali reálné zařízení do akcelerátoru řešení vzdáleného monitorování a poznamenali jste jeho připojovací řetězec zařízení.You've now added a real device to the Remote Monitoring solution accelerator and noted its device connection string. V následujících částech implementujete klientskou aplikaci, která pro připojení k vašemu řešení používá připojovací řetězec zařízení.In the following sections, you implement the client application that uses the device connection string to connect to your solution.

Klientská aplikace implementuje vestavěný model chladicího zařízení.The client application implements the built-in Chiller device model. Model zařízení akcelerátoru řešení určuje následující informace o zařízení:A solution accelerator device model specifies the following about a device:

  • Vlastnosti zařízení hlásí řešení.The properties the device reports to the solution. Například zařízení chlazení hlásí informace o jeho firmwaru a umístění.For example, a Chiller device reports information about its firmware and location.
  • Typy telemetrie, které zařízení odesílá do řešení.The types of telemetry the device sends to the solution. Například chladicí zařízení odesílá hodnoty teploty, vlhkosti a tlaku.For example, a Chiller device sends temperature, humidity, and pressure values.
  • Metody, které můžete naplánovat v řešení, které se má spustit na zařízení.The methods you can schedule from the solution to run on the device. Například chladicí zařízení musí implementovat metody restart, FirmwareUpdate, EmergencyValveReleasea IncreasePressure .For example, a Chiller device must implement Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressure methods.

V tomto kurzu se dozvíte, jak připojit reálné zařízení k akcelerátoru řešení vzdáleného monitorování.This tutorial shows you how to connect a real device to the Remote Monitoring solution accelerator. Stejně jako u většiny vložených aplikací, které běží na omezených zařízeních, je kód klienta pro aplikaci zařízení maliny PI napsán v jazyce C. V tomto kurzu sestavíte aplikaci na Malině PI s běžícím operačním systémem 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.

Pokud dáváte přednost simulaci zařízení, přečtěte si téma Vytvoření a otestování nového simulovaného zařízení.If you prefer to simulate a device, see Create and test a new simulated device.

Požadovaný hardwareRequired hardware

Stolní počítač, který vám umožní vzdálené připojení k příkazovému řádku v malin. PI.A desktop computer to enable you to connect remotely to the command line on the Raspberry Pi.

Sada Microsoft IoT Starter Kit pro malinu PI 3 nebo ekvivalentní součásti.Microsoft IoT Starter Kit for Raspberry Pi 3 or equivalent components. Tento kurz používá následující položky ze sady:This tutorial uses the following items from the kit:

  • Malina Pi 3Raspberry Pi 3
  • Karta MicroSD (s NOOBS)MicroSD Card (with NOOBS)
  • Mini kabel USBA USB Mini cable
  • Kabel EthernetAn Ethernet cable

Požadovaný desktopový softwareRequired desktop software

Na stolním počítači budete potřebovat klienta SSH, aby bylo možné vzdáleně přistupovat k příkazovému řádku v malinu PI.You need SSH client on your desktop machine to enable you to remotely access the command line on the Raspberry Pi.

  • Systém Windows nezahrnuje klienta SSH.Windows does not include an SSH client. Doporučujeme použít k disvýstupu.We recommend using PuTTY.
  • Většina distribucí a Mac OS systému Linux zahrnuje nástroj SSH nástroje příkazového řádku.Most Linux distributions and Mac OS include the command-line SSH utility. Další informace najdete v tématu SSH pomocí systému Linux nebo Mac OS.For more information, see SSH Using Linux or Mac OS.

Požadovaný software maliny PIRequired Raspberry Pi software

V tomto článku se předpokládá, že jste nainstalovali nejnovější verzi RASPBIAN OS do malin. PI.This article assumes you have installed the latest version of the Raspbian OS on your Raspberry Pi.

Následující kroky ukazují, jak připravit aplikaci malin PI pro vytváření aplikací v jazyce C, které se připojují k akcelerátoru řešení:The following steps show you how to prepare your Raspberry Pi for building a C application that connects to the solution accelerator:

  1. Připojte se k malin. PI pomocí SSH.Connect to your Raspberry Pi using ssh. Další informace najdete v tématu SSH (Secure Shell) na webu maliny PI.For more information, see SSH (Secure Shell) on the Raspberry Pi website.

  2. Pomocí následujícího příkazu aktualizujte aplikaci malin PI:Use the following command to update your Raspberry Pi:

    sudo apt-get update
    
  3. Kroky v tomto průvodci návodem vám pomohou postupovat podle kroků v tématu Nastavení vývojového prostředí pro Linux , aby se do maliny PI přidaly požadované vývojové nástroje a knihovny.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.

Zobrazit kódView the code

Vzorový kód použitý v tomto průvodci je k dispozici v úložišti GitHub pro Azure IoT C SDK.The sample code used in this guide is available in the Azure IoT C SDKs GitHub repository.

Stažení zdrojového kódu a příprava projektuDownload the source code and prepare the project

Pokud chcete připravit projekt, klonovat nebo stáhnout úložiště sad SDK služby Azure IoT C z GitHubu.To prepare the project, clone or download the Azure IoT C SDKs repository from GitHub.

Ukázka se nachází ve složce Samples/Solutions/remote_monitoring_client .The sample is located in the samples/solutions/remote_monitoring_client folder.

V textovém editoru otevřete soubor remote_monitoring. c ve složce Samples/Solutions/remote_monitoring_client .Open the remote_monitoring.c file in the samples/solutions/remote_monitoring_client folder in a text editor.

Průvodce kódemCode walkthrough

Tato část popisuje některé klíčové části ukázkového kódu a vysvětluje, jak se vztahují k akcelerátoru řešení vzdáleného monitorování.This section describes some of the key parts of the sample code and explains how they relate to the Remote Monitoring solution accelerator.

Následující fragment kódu ukazuje, jak jsou definovány hlášené vlastnosti, které popisují schopnosti zařízení.The following snippet shows how the reported properties that describe the capabilities of the device are defined. Mezi tyto vlastnosti patří:These properties include:

  • Umístění zařízení, aby akcelerátor řešení mohl přidat zařízení do mapy.The location of the device to enable the solution accelerator to add the device to the map.
  • Aktuální verze firmwaru.The current firmware version.
  • Seznam metod, které zařízení podporuje.The list of methods the device supports.
  • Schéma zpráv telemetrie odesílaných zařízenímThe 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;

Ukázka zahrnuje funkci serializeToJson , která serializaci této struktury dat pomocí knihovny Parson.The sample includes a serializeToJson function that serializes this data structure using the Parson library.

Ukázka obsahuje několik funkcí zpětného volání, které tisknou informace do konzoly, když klient komunikuje s akcelerátorem řešení: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

Následující fragment kódu ukazuje funkci device_method_callback .The following snippet shows the device_method_callback function. Tato funkce určuje akci, která se má provést při přijetí volání metody z akcelerátoru řešení.This function determines the action to take when a method call is received from the solution accelerator. Funkce přijme odkaz na strukturu dat chladicího nástroje v parametru userContextCallback .The function receives a reference to the Chiller data structure in the userContextCallback parameter. Hodnota userContextCallback je nastavena, když je funkce zpětného volání nakonfigurována v hlavní funkci: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;
}

Když akcelerátor řešení volá metodu aktualizace firmwaru, ukázka deserializace datové části JSON a spustí vlákno na pozadí pro dokončení procesu aktualizace.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. Následující fragment kódu ukazuje do_firmware_update , která běží ve vlákně: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;
}

Následující fragment kódu ukazuje, jak klient odesílá zprávu telemetrie do akcelerátoru řešení.The following snippet shows how the client sends a telemetry message to the solution accelerator. Vlastnosti zprávy obsahují schéma zprávy, které pomůžou akcelerátoru řešení zobrazit telemetrii na řídicím panelu: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);
}

Hlavní funkce v ukázce:The main function in the sample:

  • Inicializuje a ukončí podsystém sady SDK.Initializes and shuts down the SDK subsystem.
  • Inicializuje strukturu dat chladicího nástroje.Initializes the Chiller data structure.
  • Odešle hlášené vlastnosti do akcelerátoru řešení.Sends the reported properties to the solution accelerator.
  • Nakonfiguruje funkci zpětného volání pro metodu zařízení.Configures the device method callback function.
  • Odesílá simulované hodnoty telemetrie do akcelerátoru řešení.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);
        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;
}

Sestavení a spuštění aplikaceBuild and run the application

Následující postup popisuje, jak pomocí cmake vytvořit klientskou aplikaci.The following steps describe how to use CMake to build the client application. Klientská aplikace vzdáleného monitorování je sestavena jako součást procesu sestavení pro sadu SDK.The remote monitoring client application is built as part of the build process for the SDK.

  1. Upravte soubor remote_monitoring. c , který chcete <connectionstring> nahradit připojovacím řetězcem zařízení, který jste si poznamenali na začátku tohoto průvodce, když jste přidali zařízení do akcelerátoru řešení.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. Přejděte do kořenového adresáře klonovaného úložiště sad SDK služby Azure IoT C a spuštěním následujících příkazů Sestavte klientskou aplikaci: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. Spuštění klientské aplikace a odeslání telemetrie do IoT Hub:Run the client application and send telemetry to IoT Hub:

    ./samples/solutions/remote_monitoring_client/remote_monitoring_client
    

    Konzola zobrazuje zprávy jako:The console displays messages as:

    • Aplikace pošle ukázkovou telemetrii do akcelerátoru řešení.The application sends sample telemetry to the solution accelerator.
    • Reaguje na metody vyvolané z řídicího panelu řešení.Responds to methods invoked from the solution dashboard.

Zobrazení telemetrie zařízeníView device telemetry

Telemetrii odeslanou ze zařízení můžete zobrazit na stránce Device Explorer v řešení.You can view the telemetry sent from your device on the Device Explorer page in the solution.

  1. Vyberte zařízení, které jste zřídili v seznamu zařízení na stránce Device Explorer .Select the device you provisioned in the list of devices on the Device Explorer page. Na panelu se zobrazí informace o zařízení, včetně grafu telemetrie zařízení:A panel displays information about your device including a plot of the device telemetry:

    Zobrazit podrobnosti o zařízení

  2. Vyberte možnost přítlak a změňte zobrazení telemetrie:Choose Pressure to change the telemetry display:

    Zobrazit telemetrii tlaků

  3. Chcete-li zobrazit diagnostické informace o zařízení, přejděte dolů k diagnostice:To view diagnostic information about your device, scroll down to Diagnostics:

    Zobrazení diagnostiky zařízení

Fungování na zařízeníAct on your device

K vyvolání metod v zařízeních použijte stránku Device Explorer v řešení vzdáleného monitorování.To invoke methods on your devices, use the Device Explorer page in the Remote Monitoring solution. Například v zařízeních chlazení řešení vzdáleného monitorování implementují metodu restartování .For example, in the Remote Monitoring solution Chiller devices implement a Reboot method.

  1. Vyberte zařízení a přejděte na stránku Device Explorer v řešení.Choose Devices to navigate to the Device Explorer page in the solution.

  2. Vyberte zařízení, které jste zřídili v seznamu zařízení na stránce Device Explorer :Select the device you provisioned in the list of devices on the Device Explorer page:

    Výběr reálného zařízení

  3. Chcete-li zobrazit seznam metod, které můžete volat na zařízení, zvolte úlohya pak metody.To display a list of the methods you can call on your device, choose Jobs, then Methods. Pokud chcete naplánovat spuštění úlohy na více zařízeních, můžete v seznamu vybrat více zařízení.To schedule a job to run on multiple devices, you can select multiple devices in the list. Panel úlohy zobrazuje typy metod společných pro všechna zařízení, která jste vybrali.The Jobs panel shows the types of method common to all the devices you selected.

  4. Zvolte restartovat, nastavte název úlohy na RebootPhysicalChiller a pak zvolte použít:Choose Reboot, set the job name to RebootPhysicalChiller and then choose Apply:

    Naplánovat aktualizaci firmwaru

  5. Posloupnost zpráv se zobrazí v konzole spouštějící kód vašeho zařízení, zatímco simulované zařízení zpracovává tuto metodu.A sequence of messages displays in the console running your device code while the simulated device handles the method.

Poznámka

Chcete-li sledovat stav úlohy v řešení, vyberte možnost Zobrazit stav úlohy.To track the status of the job in the solution, choose View Job Status.

Další krokyNext steps

V článku přizpůsobení akcelerátoru řešení vzdáleného monitorování se dozvíte několik způsobů přizpůsobení akcelerátoru řešení.The article Customize the Remote Monitoring solution accelerator describes some ways to customize the solution accelerator.