Uw Raspberry Pi-apparaat verbinden met de Remote Monitoring solution accelerator (C)Connect your Raspberry Pi device to the Remote Monitoring solution accelerator (C)

In deze zelfstudie implementeert u een Koelunit apparaat dat de volgende telemetrie naar de externe controle verzendt oplossingsverbetering:In this tutorial, you implement a Chiller device that sends the following telemetry to the Remote Monitoring solution accelerator:

  • TemperatuurTemperature
  • Druk te verlichtenPressure
  • VochtigheidHumidity

Voor het gemak, genereert de code telemetrie voorbeeldwaarden voor de Koelunit.For simplicity, the code generates sample telemetry values for the Chiller. U kunt het voorbeeld kan uitbreiden door echte sensoren verbinding te maken met uw apparaat en echte telemetrie te verzenden.You could extend the sample by connecting real sensors to your device and sending real telemetry.

Het apparaat voorbeeld ook:The sample device also:

  • Stuurt metagegevens naar de oplossing voor het beschrijven van de mogelijkheden ervan.Sends metadata to the solution to describe its capabilities.
  • Reageert op acties die worden geactiveerd in de apparaten pagina in de oplossing.Responds to actions triggered from the Devices page in the solution.
  • Reageert op wijzigingen in de configuratie verzenden vanuit de apparaten pagina in de oplossing.Responds to configuration changes send from the Devices page in the solution.

U hebt een actief Azure-account nodig om deze zelfstudie te voltooien.To complete this tutorial, you need an active Azure account. Als u geen account hebt, kunt u binnen een paar minuten een gratis proefaccount maken.If you don't have an account, you can create a free trial account in just a couple of minutes. Zie Gratis proefversie van Azure voor meer informatie.For details, see Azure Free Trial.

Voordat u begintBefore you start

Voordat u code voor uw apparaat schrijven, de oplossingsverbetering voor externe bewaking implementeert en een nieuwe echt apparaat toevoegen aan de oplossing.Before you write any code for your device, deploy your Remote Monitoring solution accelerator and add a new real device to the solution.

De oplossingsverbetering voor externe bewaking implementerenDeploy your Remote Monitoring solution accelerator

De Koelunit apparaat in deze zelfstudie u maakt verzendt gegevens naar een exemplaar van de bewaking op afstand oplossingsverbetering.The Chiller device you create in this tutorial sends data to an instance of the Remote Monitoring solution accelerator. Als u de oplossingsverbetering voor externe controle in uw Azure-account nog niet hebt ingericht, Zie de oplossingsverbetering voor externe bewaking implementerenIf you haven't already provisioned the Remote Monitoring solution accelerator in your Azure account, see Deploy the Remote Monitoring solution accelerator

Wanneer het implementatieproces voor de oplossing voor externe controle is voltooid, klikt u op starten dashboard van de oplossing in uw browser openen.When the deployment process for the Remote Monitoring solution finishes, click Launch to open the solution dashboard in your browser.

Dashboard van de oplossing

Uw apparaat toevoegt aan de oplossing voor externe controleAdd your device to the Remote Monitoring solution

Notitie

Als u al een apparaat in uw oplossing hebt toegevoegd, kunt u deze stap overslaan.If you have already added a device in your solution, you can skip this step. De volgende stap is echter vereist dat de verbindingsreeks van uw apparaat.However, the next step requires your device connection string. U kunt ophalen van een apparaat connection string vanuit de Azure-portal of met behulp van de az iot CLI-hulpprogramma.You can retrieve a device's connection string from the Azure portal or using the az iot CLI tool.

Voor een apparaat verbinding maakt met de oplossingsversnellers, moet deze zelf identificeren bij IoT Hub met geldige referenties.For a device to connect to the solution accelerator, it must identify itself to IoT Hub using valid credentials. U hebt de mogelijkheid om op te slaan van de verbindingsreeks met deze referenties wanneer u het apparaat aan de oplossing toevoegt.You have the opportunity to save the device connection string that contains these credentials when you add the device to the solution. U kunt de apparaatverbindingsreeks opnemen in uw clienttoepassing verderop in deze zelfstudie.You include the device connection string in your client application later in this tutorial.

Als u wilt een apparaat toevoegt aan uw oplossing voor externe controle, voltooit u de volgende stappen uit op de Device Explorer pagina in de oplossing:To add a device to your Remote Monitoring solution, complete the following steps on the Device Explorer page in the solution:

  1. Kies + nieuwe apparaat, en kies vervolgens echte als de apparaattype:Choose + New device, and then choose Real as the Device type:

    Echt apparaat toevoegen

  2. Voer fysieke Koelunit als de apparaat-ID.Enter Physical-chiller as the Device ID. Kies de symmetrische sleutel en automatisch sleutels genereren opties:Choose the Symmetric Key and Auto generate keys options:

    Apparaatopties voor selecteren

  3. Kies toepassen.Choose Apply. Maak een notitie van de apparaat-ID, primaire sleutel, en Connection string primaire sleutel waarden:Then make a note of the Device ID, Primary Key, and Connection string primary key values:

    Referenties ophalen

U hebt nu een echt apparaat toegevoegd aan de oplossingsverbetering voor externe controle en de apparaatverbindingsreeks die u hebt genoteerd.You've now added a real device to the Remote Monitoring solution accelerator and noted its device connection string. In de volgende secties vindt u op de clienttoepassing die gebruikmaakt van de verbindingsreeks van het apparaat verbinding maken met uw oplossing implementeren.In the following sections, you implement the client application that uses the device connection string to connect to your solution.

De clienttoepassing implementeert de ingebouwde Koelunit Apparaatmodel.The client application implements the built-in Chiller device model. Een model solution accelerator apparaat Hiermee geeft u de volgende met betrekking tot een apparaat:A solution accelerator device model specifies the following about a device:

  • De eigenschappen van het apparaat rapporteert aan de oplossing.The properties the device reports to the solution. Bijvoorbeeld, een Koelunit apparaat rapporteert informatie over de firmware en de locatie.For example, a Chiller device reports information about its firmware and location.
  • De typen telemetrie wordt het apparaat verzendt naar de oplossing.The types of telemetry the device sends to the solution. Bijvoorbeeld, een Koelunit apparaat verzendt temperatuur, vochtigheid en druk te verlichten waarden.For example, a Chiller device sends temperature, humidity, and pressure values.
  • De methoden die u vanuit de oplossing plannen kunt om uit te voeren op het apparaat.The methods you can schedule from the solution to run on the device. Bijvoorbeeld, een Koelunit apparaat moet worden geïmplementeerd opnieuw opstarten, FirmwareUpdate, EmergencyValveRelease, en IncreasePressure methoden.For example, a Chiller device must implement Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressure methods.

Deze zelfstudie leert u hoe u een echt apparaat verbinden met de oplossingsverbetering voor externe controle.This tutorial shows you how to connect a real device to the Remote Monitoring solution accelerator. Net als bij de meeste embedded-toepassingen die worden uitgevoerd op apparaten met beperkte, is de clientcode voor de toepassing Raspberry Pi-apparaat geschreven in C. In deze zelfstudie bouwt u de toepassing op een Raspberry Pi met de 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.

Als u liever een apparaat simuleren, Zie maken en test een nieuw gesimuleerd apparaat.If you prefer to simulate a device, see Create and test a new simulated device.

Vereiste hardwareRequired hardware

Een desktopcomputer waarmee u kunt extern verbinding maken met de opdrachtregel op de Raspberry Pi.A desktop computer to enable you to connect remotely to the command line on the Raspberry Pi.

Microsoft IoT Starter Kit voor Raspberry Pi 3 of equivalente onderdelen.Microsoft IoT Starter Kit for Raspberry Pi 3 or equivalent components. In deze zelfstudie wordt de volgende items uit de kit:This tutorial uses the following items from the kit:

  • Raspberry Pi 3Raspberry Pi 3
  • MicroSD-kaart (met NOOBS)MicroSD Card (with NOOBS)
  • Een Mini USB-kabelA USB Mini cable
  • Een Ethernet-kabelAn Ethernet cable

Vereiste bureaublad-softwareRequired desktop software

SSH-client moet u op de computer waarmee u kunt voor externe toegang tot de opdrachtregel op de Raspberry Pi.You need SSH client on your desktop machine to enable you to remotely access the command line on the Raspberry Pi.

  • Windows bevat geen een SSH-client.Windows does not include an SSH client. Wordt u aangeraden PuTTY.We recommend using PuTTY.
  • De meeste Linux-distributies en Mac OS omvatten het SSH-opdrachtregelprogramma.Most Linux distributions and Mac OS include the command-line SSH utility. Zie voor meer informatie, SSH met behulp van Linux- of Mac OS.For more information, see SSH Using Linux or Mac OS.

Vereiste software voor Raspberry PiRequired Raspberry Pi software

In dit artikel wordt ervan uitgegaan dat u hebt geïnstalleerd dat de nieuwste versie van de Raspbian besturingssysteem op uw Raspberry Pi.This article assumes you have installed the latest version of the Raspbian OS on your Raspberry Pi.

De volgende stappen laten zien hoe u uw Raspberry Pi voorbereiden voor het bouwen van een toepassing C die verbinding met de oplossingsversnellers maakt:The following steps show you how to prepare your Raspberry Pi for building a C application that connects to the solution accelerator:

  1. Verbinding maken met uw Raspberry Pi met ssh.Connect to your Raspberry Pi using ssh. Zie voor meer informatie, SSH (Secure Shell) op de Raspberry Pi website.For more information, see SSH (Secure Shell) on the Raspberry Pi website.

  2. Gebruik de volgende opdracht uit om bij te werken uw Raspberry Pi:Use the following command to update your Raspberry Pi:

    sudo apt-get update
    
  3. Om uit te voeren de stappen in deze gebruiksaanwijzing Volg de stappen in uw Linux-ontwikkelomgeving instellen de vereiste ontwikkelprogramma's en bibliotheken toevoegen aan uw 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.

De code weergevenView the code

De voorbeeldcode gebruikt in deze handleiding is beschikbaar in de Azure IoT C SDK's GitHub-opslagplaats.The sample code used in this guide is available in the Azure IoT C SDKs GitHub repository.

De broncode downloaden en voorbereiden van het projectDownload the source code and prepare the project

Om voor te bereiden op het project, klonen of downloaden de opslagplaats Azure IoT C SDKs vanuit GitHub.To prepare the project, clone or download the Azure IoT C SDKs repository from GitHub.

Het voorbeeld bevindt zich de samples/oplossingen/remote_monitoring_client map.The sample is located in the samples/solutions/remote_monitoring_client folder.

Open de remote_monitoring.c -bestand in de samples/oplossingen/remote_monitoring_client map in een teksteditor.Open the remote_monitoring.c file in the samples/solutions/remote_monitoring_client folder in a text editor.

Code-overzichtCode walkthrough

Deze sectie beschrijft een aantal van de belangrijkste onderdelen van de voorbeeldcode en wordt uitgelegd hoe deze in verband met de oplossingsverbetering voor externe controle.This section describes some of the key parts of the sample code and explains how they relate to the Remote Monitoring solution accelerator.

Het volgende fragment toont hoe de gerapporteerde eigenschappen die de mogelijkheden van het apparaat beschrijven worden gedefinieerd.The following snippet shows how the reported properties that describe the capabilities of the device are defined. Deze eigenschappen zijn onder andere:These properties include:

  • De locatie van het apparaat om in te schakelen de oplossingsverbetering voor het apparaat toevoegen aan de kaart.The location of the device to enable the solution accelerator to add the device to the map.
  • De huidige firmwareversie.The current firmware version.
  • De lijst met methoden die biedt ondersteuning voor het apparaat.The list of methods the device supports.
  • Het schema van de telemetrieberichten die door het apparaat verzonden.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;

Het voorbeeld bevat een serializeToJson -functie die deze gegevensstructuur met behulp van de bibliotheek Parson serialiseert.The sample includes a serializeToJson function that serializes this data structure using the Parson library.

Het voorbeeld bevat verschillende callback-functies die gegevens naar de console afdrukken als de client met de oplossingsversnellers communiceert: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

Het volgende codefragment bevat de device_method_callback functie.The following snippet shows the device_method_callback function. Deze functie bepaalt de actie te ondernemen wanneer een methodeaanroep wordt ontvangen van de solution accelerator.This function determines the action to take when a method call is received from the solution accelerator. De functie ontvangt een verwijzing naar de Koelunit gegevens structureren de userContextCallback parameter.The function receives a reference to the Chiller data structure in the userContextCallback parameter. De waarde van userContextCallback wordt ingesteld wanneer de callback-functie is geconfigureerd in de belangrijkste functie: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;
}

Wanneer de oplossingsverbetering voor de firmware-update-methode aanroept, wordt het voorbeeld gedeserialiseerd van de JSON-nettolading en een achtergrond-thread voor het voltooien van het updateproces wordt gestart.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. Het volgende codefragment bevat de do_firmware_update die wordt uitgevoerd op de 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;
}

Het volgende fragment toont hoe de client een bericht telemetrie verzendt naar de solution accelerator.The following snippet shows how the client sends a telemetry message to the solution accelerator. De eigenschappen van berichten zijn onder andere het berichtschema om te helpen de oplossingsverbetering voor de telemetrie weergegeven op het 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);
}

De belangrijkste functie in het voorbeeld:The main function in the sample:

  • Wordt geïnitialiseerd en de SDK-subsysteem wordt afgesloten.Initializes and shuts down the SDK subsystem.
  • Initialiseert de Koelunit gegevensstructuur.Initializes the Chiller data structure.
  • De gerapporteerde eigenschappen stuurt naar de solution accelerator.Sends the reported properties to the solution accelerator.
  • Hiermee configureert u het apparaat methode callback-functie.Configures the device method callback function.
  • Stuurt gesimuleerde telemetriewaarden naar de 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;
}

De toepassing bouwen en uitvoeren.Build and run the application

De volgende stappen wordt beschreven hoe u CMake om de clienttoepassing te bouwen.The following steps describe how to use CMake to build the client application. De clienttoepassing voor externe controle is gebouwd als onderdeel van het bouwproces voor de SDK.The remote monitoring client application is built as part of the build process for the SDK.

  1. Bewerk de remote_monitoring.c vervangen door het bestand <connectionstring> met de apparaatverbindingsreeks die u hebt genoteerd aan het begin van deze gebruiksaanwijzing wanneer u een apparaat toegevoegd aan de 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. Ga naar de hoofdmap van de gekloonde kopie van de opslagplaats Azure IoT C SDKs opslagplaats en de volgende opdrachten om de clienttoepassing te bouwen: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. Voer de clienttoepassing en verzenden van telemetrie naar IoT Hub:Run the client application and send telemetry to IoT Hub:

    ./samples/solutions/remote_monitoring_client/remote_monitoring_client
    

    De console worden berichten weergegeven:The console displays messages as:

    • De toepassing verzendt voorbeeld telemetrie naar de solution accelerator.The application sends sample telemetry to the solution accelerator.
    • Reageert op methoden aangeroepen vanuit het dashboard van de oplossing.Responds to methods invoked from the solution dashboard.

Telemetrie van apparaten weergevenView device telemetry

U ziet de telemetrie van uw apparaat verzonden op de Device Explorer pagina in de oplossing.You can view the telemetry sent from your device on the Device Explorer page in the solution.

  1. Selecteer het apparaat dat u hebt ingericht in de lijst met apparaten op de Device Explorer pagina.Select the device you provisioned in the list of devices on the Device Explorer page. Een paneel geeft informatie weer over uw apparaat met inbegrip van een diagram van de telemetrie van apparaten:A panel displays information about your device including a plot of the device telemetry:

    Details van apparaat

  2. Kies druk te verlichten om de telemetrie-weergave te wijzigen:Choose Pressure to change the telemetry display:

    Druk te verlichten-telemetrie weergeven

  3. Als u wilt weergeven van diagnostische gegevens over uw apparaat, schuif omlaag naar Diagnostics:To view diagnostic information about your device, scroll down to Diagnostics:

    Apparaat diagnostische gegevens over weergeven

Reageren op uw apparaatAct on your device

Voor het aanroepen van methoden op uw apparaten, gebruikt u de Device Explorer pagina in de oplossing voor externe controle.To invoke methods on your devices, use the Device Explorer page in the Remote Monitoring solution. Bijvoorbeeld, in de oplossing voor externe controle Koelunit apparaten implementeren een opnieuw opstarten methode.For example, in the Remote Monitoring solution Chiller devices implement a Reboot method.

  1. Kies apparaten om te navigeren naar de Device Explorer pagina in de oplossing.Choose Devices to navigate to the Device Explorer page in the solution.

  2. Selecteer het apparaat dat u hebt ingericht in de lijst met apparaten op de Device Explorer pagina:Select the device you provisioned in the list of devices on the Device Explorer page:

    Selecteer uw echte apparaat

  3. Voor een lijst van de methoden die u op uw apparaat aanroepen kunt, kies taken, klikt u vervolgens methoden.To display a list of the methods you can call on your device, choose Jobs, then Methods. Als u een taak uit te voeren op meerdere apparaten plannen, kunt u meerdere apparaten selecteren in de lijst.To schedule a job to run on multiple devices, you can select multiple devices in the list. De taken deelvenster ziet u de typen van de methode voor alle apparaten die u hebt geselecteerd.The Jobs panel shows the types of method common to all the devices you selected.

  4. Kies opnieuw opstarten, naam van de taak ingesteld op RebootPhysicalChiller en kies vervolgens toepassen:Choose Reboot, set the job name to RebootPhysicalChiller and then choose Apply:

    Plannen van de firmware-update

  5. Een reeks berichten weergegeven in de console die de apparaatcode uitgevoerd terwijl het gesimuleerde apparaat de methode afhandelt.A sequence of messages displays in the console running your device code while the simulated device handles the method.

Notitie

Kies voor het volgen van de status van de taak in de oplossing, weergave taakstatus.To track the status of the job in the solution, choose View Job Status.

Volgende stappenNext steps

Het artikel aanpassen van de oplossingsverbetering voor externe controle worden enkele manieren beschreven om aan te passen de solution accelerator.The article Customize the Remote Monitoring solution accelerator describes some ways to customize the solution accelerator.