Anslut enheten till lösningsacceleratorn för fjärrövervakning (Windows)Connect your device to the Remote Monitoring solution accelerator (Windows)

I den här självstudien får du implementera en kylaggregat enhet som skickar följande telemetri till den fjärrövervakning lösningsaccelerator:In this tutorial, you implement a Chiller device that sends the following telemetry to the Remote Monitoring solution accelerator:

  • TemperaturTemperature
  • Hög belastningPressure
  • FuktighetHumidity

För enkelhetens skull genererar koden exempelvärden telemetri för den kylaggregat.For simplicity, the code generates sample telemetry values for the Chiller. Du kan utöka exemplet genom att ansluta riktiga sensorer till enheten och skicka riktig telemetri.You could extend the sample by connecting real sensors to your device and sending real telemetry.

Exemplet enheten också:The sample device also:

  • Skickar metadata till lösningen att beskriva dess funktioner.Sends metadata to the solution to describe its capabilities.
  • Svarar på åtgärder som utlöses från den enheter sidan i lösningen.Responds to actions triggered from the Devices page in the solution.
  • Svarar på ändringar i konfigurationen skicka från den enheter sidan i lösningen.Responds to configuration changes send from the Devices page in the solution.

Du behöver ett Azure-konto för att slutföra den här självstudiekursen.To complete this tutorial, you need an active Azure account. Om du inte har något konto kan skapa du ett kostnadsfritt utvärderingskonto på bara några minuter.If you don't have an account, you can create a free trial account in just a couple of minutes. Mer information om den kostnadsfria utvärderingsversionen av Azure.For details, see Azure Free Trial.

Innan du börjarBefore you start

Innan du kan skriva kod för enheten, distribuerar lösningsacceleratorn för fjärrövervakning och lägga till en ny riktig enhet i lösningen.Before you write any code for your device, deploy your Remote Monitoring solution accelerator and add a new real device to the solution.

Distribuera lösningsacceleratorn för fjärrövervakningDeploy your Remote Monitoring solution accelerator

Den kylaggregat enheten som du skapar i den här självstudien skickar data till en instans av den fjärrövervakning lösningsaccelerator.The Chiller device you create in this tutorial sends data to an instance of the Remote Monitoring solution accelerator. Om du inte redan har etablerat lösningsacceleratorn för fjärrövervakning i ditt Azure-konto, se distribuerar lösningsacceleratorn för fjärrövervakningIf you haven't already provisioned the Remote Monitoring solution accelerator in your Azure account, see Deploy the Remote Monitoring solution accelerator

När distributionsprocessen för lösningen för fjärrövervakning är klar klickar du på starta att öppna instrumentpanelen för lösningen i din webbläsare.When the deployment process for the Remote Monitoring solution finishes, click Launch to open the solution dashboard in your browser.

Instrumentpanelen för lösningen

Lägga till din enhet i lösningen för fjärrövervakningAdd your device to the Remote Monitoring solution

Anteckning

Om du har redan lagt till en enhet i din lösning, kan du hoppa över det här steget.If you have already added a device in your solution, you can skip this step. Nästa steg kräver dock enhetens anslutningssträng.However, the next step requires your device connection string. Du kan hämta anslutningssträngen för en enhet från den Azure-portalen eller med hjälp av den az iot CLI-verktyget.You can retrieve a device's connection string from the Azure portal or using the az iot CLI tool.

För en enhet att ansluta till lösningsaccelerator kan identifiera den sig för IoT Hub med giltiga autentiseringsuppgifter.For a device to connect to the solution accelerator, it must identify itself to IoT Hub using valid credentials. Du har möjlighet att spara enhetens anslutningssträng som innehåller de här autentiseringsuppgifterna när du lägger till enheten i lösningen.You have the opportunity to save the device connection string that contains these credentials when you add the device to the solution. Du kan inkludera enhetens anslutningssträng i klientprogrammet senare i den här självstudien.You include the device connection string in your client application later in this tutorial.

Om du vill lägga till en enhet till din fjärrövervakningslösning utför du följande steg på den Device Explorer sidan i lösningen:To add a device to your Remote Monitoring solution, complete the following steps on the Device Explorer page in the solution:

  1. Välj + ny enhet, och välj sedan verkliga som den enhetstyp:Choose + New device, and then choose Real as the Device type:

    Lägga till en riktig enhet

  2. Ange fysiska kylaggregat som enhetens ID.Enter Physical-chiller as the Device ID. Välj den symmetrisk nyckel och generera nycklar automatiskt alternativ:Choose the Symmetric Key and Auto generate keys options:

    Välj alternativ för enhet

  3. Välj gäller.Choose Apply. Skriv ned den enhets-ID, primärnyckel, och Connection string primärnyckel värden:Then make a note of the Device ID, Primary Key, and Connection string primary key values:

    Hämta autentiseringsuppgifter

Du har nu lagt till en riktig enhet att lösningsacceleratorn för fjärrövervakning och anges dess enhetens anslutningssträng.You've now added a real device to the Remote Monitoring solution accelerator and noted its device connection string. I följande avsnitt kan du implementera klientprogram som använder enhetens anslutningssträng för att ansluta till din lösning.In the following sections, you implement the client application that uses the device connection string to connect to your solution.

Klientprogrammet implementerar inbyggt kylaggregat enhetsmodell.The client application implements the built-in Chiller device model. En enhetsmodell för solution accelerator anger följande om en enhet:A solution accelerator device model specifies the following about a device:

  • Egenskaperna enheten rapporterar till lösningen.The properties the device reports to the solution. Till exempel en kylaggregat enheten rapporterar information om den inbyggda programvaran och placering.For example, a Chiller device reports information about its firmware and location.
  • Typer av telemetri som enheten skickar till lösningen.The types of telemetry the device sends to the solution. Till exempel en kylaggregat enheten skickar temperatur, fuktighet och värden för tryck.For example, a Chiller device sends temperature, humidity, and pressure values.
  • De metoder som du kan schemalägga från lösningen ska köras på enheten.The methods you can schedule from the solution to run on the device. Till exempel en kylaggregat enheten måste implementera omstart, FirmwareUpdate, EmergencyValveRelease, och IncreasePressure metoder.For example, a Chiller device must implement Reboot, FirmwareUpdate, EmergencyValveRelease, and IncreasePressure methods.

Den här självstudien visar hur du ansluter en riktig enhet till lösningsacceleratorn för fjärrövervakning.This tutorial shows you how to connect a real device to the Remote Monitoring solution accelerator.

Precis som med de flesta embedded-program som körs på begränsade enheter, är klientkod för enhet-programmet skrivna i C. I den här självstudien skapar du enheten-klientprogrammet på en dator som kör Windows.As with most embedded applications that run on constrained devices, the client code for the device application is written in C. In this tutorial, you build the device client application on a machine running Windows.

Om du föredrar att simulera en enhet, se skapa och testa en ny simulerad enhet.If you prefer to simulate a device, see Create and test a new simulated device.

Nödvändiga komponenterPrerequisites

För att slutföra stegen i den här guiden följer du stegen i konfigurera din Windows-utvecklingsmiljö att lägga till de nödvändiga utvecklingsverktygen och -bibliotek i din Windows-dator.To complete the steps in this how-to guide follow the steps in set up your Windows development environment to add the required development tools and libraries to your Windows machine.

Visa kodenView the code

Den exempelkoden används i den här guiden är tillgänglig i Azure IoT C SDK: er GitHub-lagringsplatsen.The sample code used in this guide is available in the Azure IoT C SDKs GitHub repository.

Ladda ned källkoden och Förbered projektetDownload the source code and prepare the project

Förbereda projektet, klona databasen för Azure IoT C SDKs från GitHub.To prepare the project, clone the Azure IoT C SDKs repository from GitHub.

Du hittar exemplet i den samples/lösningar/remote_monitoring_client mapp.The sample is located in the samples/solutions/remote_monitoring_client folder.

Öppna den remote_monitoring.c fil i den samples/lösningar/remote_monitoring_client mapp i en textredigerare.Open the remote_monitoring.c file in the samples/solutions/remote_monitoring_client folder in a text editor.

KodhandledningCode walkthrough

Det här avsnittet beskrivs några av de viktigaste delarna av exempelkoden och hur de relaterar till lösningsacceleratorn för fjärrövervakning.This section describes some of the key parts of the sample code and explains how they relate to the Remote Monitoring solution accelerator.

Följande kodfragment visar hur rapporterade egenskaper som beskriver funktionerna i enheten har definierats.The following snippet shows how the reported properties that describe the capabilities of the device are defined. De här egenskaperna är:These properties include:

  • Platsen för enheten för att aktivera lösningsaccelerator att lägga till enheten på kartan.The location of the device to enable the solution accelerator to add the device to the map.
  • Den aktuella versionen för inbyggd programvara.The current firmware version.
  • Lista över metoder som enheten har stöd för.The list of methods the device supports.
  • Schemat för telemetrimeddelanden som skickas av enheten.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;

Exemplet innehåller en serializeToJson funktion som Serialiserar den här datastrukturen med Parson-biblioteket.The sample includes a serializeToJson function that serializes this data structure using the Parson library.

Exemplet innehåller flera återanropsfunktionerna som skriver ut information till konsolen när klienten interagerar med 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

I följande fragment visas den device_method_callback funktion.The following snippet shows the device_method_callback function. Den här funktionen anger åtgärden som ska vidtas när ett metodanrop tas emot från solution accelerator.This function determines the action to take when a method call is received from the solution accelerator. Funktionen tar emot en referens till den kylaggregat data struktur i den userContextCallback parametern.The function receives a reference to the Chiller data structure in the userContextCallback parameter. Värdet för userContextCallback anges när Återanropsfunktionen konfigureras i den huvudsakliga funktionen: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;
}

När solution accelerator anropar metoden för uppdatering av inbyggd programvara, exemplet deserializes JSON-nyttolasten och startar en bakgrundstråd för att slutföra uppdateringsprocessen.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. I följande fragment visas den do_firmware_update som körs på tråden: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;
}

Följande kodfragment visar hur klienten skickar en telemetrimeddelanden till solution accelerator.The following snippet shows how the client sends a telemetry message to the solution accelerator. Meddelandeegenskaperna inkluderar meddelande schemat för att hjälpa lösningsaccelerator visa telemetri på instrumentpanelen: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);
}

Den huvudsakliga funktion i det här exemplet:The main function in the sample:

  • Initierar och stänger av SDK-undersystemet.Initializes and shuts down the SDK subsystem.
  • Initierar den kylaggregat datastruktur.Initializes the Chiller data structure.
  • Skickar rapporterade egenskaper till solution accelerator.Sends the reported properties to the solution accelerator.
  • Konfigurerar återanropsfunktion för enhet-metoden.Configures the device method callback function.
  • Skickar simulerade telemetrivärden för 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;
}

Skapa och köra exempelappenBuild and run the sample

  1. Redigera den remote_monitoring.c filen för att ersätta <connectionstring> med enhetens anslutningssträng som du antecknade i början av den här guiden när du har lagt till en enhet för 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. Följ stegen i skapa C SDK i Windows att bygga SDK: N och fjärransluten övervakning klientprogrammet.Follow the steps in Build the C SDK in Windows to build the SDK and the remote monitoring client application.

  3. Vid kommandotolken använde du för att skapa lösningen genom att köra:At the command-prompt you used to build the solution, run:

    samples\solutions\remote_monitoring_client\Release\remote_monitoring_client.exe
    

    Konsolen visar meddelanden som:The console displays messages as:

    • Programmet skickar exempel telemetri till solution accelerator.The application sends sample telemetry to the solution accelerator.
    • Svarar på metoderna som anropas från lösningens instrumentpanel.Responds to methods invoked from the solution dashboard.

Visa enhetstelemetriView device telemetry

Du kan visa telemetri som skickas från din enhet den Device Explorer sidan i lösningen.You can view the telemetry sent from your device on the Device Explorer page in the solution.

  1. Välj den enhet som du har etablerat i listan över enheter på den Device Explorer sidan.Select the device you provisioned in the list of devices on the Device Explorer page. En panel visar information om enheten till exempel en rityta för enhetstelemetri som:A panel displays information about your device including a plot of the device telemetry:

    Visa information om enhet

  2. Välj tryck ändra visningen av telemetri:Choose Pressure to change the telemetry display:

    Visa tryck telemetri

  3. Om du vill visa diagnostisk information om din enhet, bläddra ned till diagnostik:To view diagnostic information about your device, scroll down to Diagnostics:

    Visa enhet diagnostik

Agera på din enhetAct on your device

Om du vill anropa metoder på dina enheter, använda den Device Explorer sida i lösningen för fjärrövervakning.To invoke methods on your devices, use the Device Explorer page in the Remote Monitoring solution. Till exempel i lösningen för fjärrövervakning kylaggregat enheter implementera en omstart metod.For example, in the Remote Monitoring solution Chiller devices implement a Reboot method.

  1. Välj enheter att navigera till den Device Explorer sidan i lösningen.Choose Devices to navigate to the Device Explorer page in the solution.

  2. Välj den enhet som du har etablerat i listan över enheter på den Device Explorer sidan:Select the device you provisioned in the list of devices on the Device Explorer page:

    Välj den verkliga enheten

  3. Om du vill visa en lista över de metoder som du kan anropa på enheten, Välj jobb, sedan metoder.To display a list of the methods you can call on your device, choose Jobs, then Methods. Om du vill schemalägga ett jobb ska köras på flera enheter, kan du välja flera enheter i listan.To schedule a job to run on multiple devices, you can select multiple devices in the list. Den jobb panelen visas typerna av metoden som är gemensamma för alla enheter som du har valt.The Jobs panel shows the types of method common to all the devices you selected.

  4. Välj omstart, inställd på jobbnamnet RebootPhysicalChiller och välj sedan tillämpa:Choose Reboot, set the job name to RebootPhysicalChiller and then choose Apply:

    Schemalägg uppdatering av inbyggd programvara

  5. En serie meddelanden visas i konsolen som kör enhetskoden när den simulerade enheten hanterar metoden.A sequence of messages displays in the console running your device code while the simulated device handles the method.

Anteckning

Om du vill spåra statusen för jobbet i lösningen, Välj Visa jobbstatus.To track the status of the job in the solution, choose View Job Status.

Nästa stegNext steps

Artikeln anpassa lösningsacceleratorn för fjärrövervakning beskriver några sätt att anpassa solution accelerator.The article Customize the Remote Monitoring solution accelerator describes some ways to customize the solution accelerator.