Łączenie urządzenia ze wstępnie skonfigurowanym rozwiązaniem do monitorowania zdalnego (Linux)

Artykuł
11/02/2017

Omówienie scenariusza

W tym scenariuszu utworzysz urządzenie, które wysyła następujące dane telemetryczne do wstępnie skonfigurowanego rozwiązania do monitorowania zdalnego:

Temperatura zewnętrzna
Temperatura wewnętrzna
Wilgotność

Dla uproszczenia kod na urządzeniu generuje przykładowe wartości, ale zachęcamy do rozszerzenia przykładu przez podłączenie rzeczywistych czujników do urządzenia i wysyłanie rzeczywistych danych telemetrycznych.

Urządzenie potrafi także odpowiadać na metody wywołane z poziomu pulpitu nawigacyjnego rozwiązania i wartości żądanych właściwości ustawione na pulpicie nawigacyjnym rozwiązania.

Do wykonania kroków tego samouczka jest potrzebne aktywne konto platformy Azure. Jeśli nie masz konta, możesz utworzyć bezpłatne konto próbne w zaledwie kilka minut. Aby uzyskać szczegółowe informacje, zobacz Bezpłatna wersja próbna platformy Azure.

Przed rozpoczęciem

Przed przystąpieniem do pisania jakiegokolwiek kodu dla urządzenia musisz przeprowadzić aprowizację wstępnie skonfigurowanego rozwiązania do monitorowania zdalnego i nowego niestandardowego urządzenia w ramach tego rozwiązania.

Aprowizowanie wstępnie skonfigurowanego rozwiązania do monitorowania zdalnego

Urządzenie, które utworzysz w ramach tego samouczka, będzie wysyłać dane do wystąpienia wstępnie skonfigurowanego rozwiązania do monitorowania zdalnego. Jeśli jeszcze nie przeprowadzono aprowizacji wstępnie skonfigurowanego rozwiązania do monitorowania zdalnego na Twoim koncie platformy Azure, wykonaj poniższe kroki:

https://www.azureiotsolutions.com/ Na stronie kliknij, + aby utworzyć rozwiązanie.
Kliknij pozycję Wybierz w panelu Monitorowanie zdalne, aby utworzyć rozwiązanie.
Na stronie Tworzenie rozwiązania do monitorowania zdalnego w polu Nazwa rozwiązania wprowadź wybraną nazwę rozwiązania, w polu Region wybierz region, w którym chcesz przeprowadzić wdrożenie, a następnie wybierz subskrypcję platformy Azure, której chcesz użyć. Następnie kliknij pozycję Utwórz rozwiązanie.
Zaczekaj na ukończenie procesu aprowizowania.

Ostrzeżenie

Wstępnie skonfigurowane rozwiązania korzystają z płatnych usług platformy Azure. Pamiętaj o usunięciu wstępnie skonfigurowanego rozwiązania ze swojej subskrypcji po zakończeniu pracy z nim, aby uniknąć wszelkich zbędnych opłat. Możesz całkowicie usunąć wstępnie skonfigurowane rozwiązanie z subskrypcji, odwiedzając https://www.azureiotsolutions.com/ stronę.

Po zakończeniu procesu aprowizowania rozwiązania do monitorowania zdalnego kliknij pozycję Uruchom, aby otworzyć pulpit nawigacyjny rozwiązania w przeglądarce.

Pulpit nawigacyjny rozwiązania

Aprowizowanie urządzenia w ramach rozwiązania do monitorowania zdalnego

Uwaga

Jeśli już przeprowadzono aprowizację urządzenia w ramach rozwiązania, możesz pominąć ten krok. Podczas tworzenia aplikacji klienckiej musisz znać poświadczenia urządzenia.

Aby urządzenie mogło nawiązać połączenie ze wstępnie skonfigurowanym rozwiązaniem, musi ono zidentyfikować się względem usługi IoT Hub za pomocą prawidłowych poświadczeń. Poświadczenia urządzenia możesz pobrać z pulpitu nawigacyjnego rozwiązania. W dalszej części tego samouczka podasz te poświadczenia urządzenia w Twojej aplikacji klienckiej.

Aby dodać urządzenie do swojego rozwiązania do monitorowania zdalnego, wykonaj poniższe kroki na pulpicie nawigacyjnym rozwiązania:

W lewym dolnym rogu pulpitu nawigacyjnego kliknij pozycję Dodaj urządzenie.
W panelu Urządzenie niestandardowe kliknij pozycję Dodaj nowe.
Wybierz pozycję Pozwól mi zdefiniować własny identyfikator urządzenia. Wprowadź identyfikator urządzenia, na przykład moje_urządzenie, kliknij pozycję Sprawdź identyfikator, aby sprawdzić, czy dana nazwa nie jest już używana, a następnie kliknij pozycję Utwórz, aby przeprowadzić aprowizację urządzenia.
Zanotuj poświadczenia urządzenia (identyfikator urządzenia, nazwę hosta usługi IoT Hub i klucz urządzenia). Twoja aplikacja kliencka potrzebuje tych wartości, aby mogła nawiązać połączenie z rozwiązaniem do monitorowania zdalnego. Następnie kliknij przycisk Gotowe.
Wybierz urządzenie na liście urządzeń na pulpicie nawigacyjnym rozwiązania. Następnie w panelu Szczegóły urządzenia kliknij pozycję Włącz urządzenie. Stan Twojego urządzenia to teraz Uruchomione. Rozwiązanie do monitorowania zdalnego może teraz odbierać dane telemetryczne z Twojego urządzenia i wywoływać metody na tym urządzeniu.

Kompilowanie i uruchamianie przykładowego klienta języka C w systemie Linux

Poniższe kroki pokazują, jak utworzyć aplikację kliencką, która komunikuje się ze wstępnie skonfigurowanym rozwiązaniem do monitorowania zdalnego. Ta aplikacja jest napisana w języku C i kompilowana i uruchamiana w systemie Ubuntu Linux.

Do wykonania tych kroków potrzebne jest urządzenie z systemem Ubuntu w wersji 15.04 lub 15.10. Przed kontynuowaniem zainstaluj pakiety wymagań wstępnych na urządzeniu z systemem Ubuntu przy użyciu następującego polecenia:

sudo apt-get install cmake gcc g++

Instalowanie bibliotek klienckich na urządzeniu

Biblioteki klienta Azure IoT Hub są dostępne jako pakiet, który można zainstalować na urządzeniu z systemem Ubuntu przy użyciu polecenia apt-get. Wykonaj następujące kroki, aby zainstalować pakiet zawierający bibliotekę klienta IoT Hub i pliki nagłówkowe na komputerze z systemem Ubuntu:

W powłoce dodaj repozytorium AzureIoT do komputera:

sudo add-apt-repository ppa:aziotsdklinux/ppa-azureiot
sudo apt-get update

Instalowanie pakietu azure-iot-sdk-c-dev

sudo apt-get install -y azure-iot-sdk-c-dev

Instalowanie analizatora parson JSON

Biblioteki klienta IoT Hub używają analizatora Parson JSON do analizowania ładunków komunikatów. W odpowiednim folderze na komputerze sklonuj repozytorium Parson GitHub przy użyciu następującego polecenia:

git clone https://github.com/kgabis/parson.git

Przygotowywanie projektu

Na maszynie z systemem Ubuntu utwórz folder o nazwie remote_monitoring. W folderze remote_monitoring :

Utwórz cztery pliki main.c, remote_monitoring.c, remote_monitoring.h i CMakeLists.txt.
Utwórz folder o nazwie parson.

Skopiuj pliki parson.c i parson.h z lokalnej kopii repozytorium Parson do folderu remote_monitoring/parson .

W edytorze tekstów otwórz plik remote_monitoring.c . Dodaj następujące instrukcje #include:

#include "iothubtransportmqtt.h"
#include "schemalib.h"
#include "iothub_client.h"
#include "serializer_devicetwin.h"
#include "schemaserializer.h"
#include "azure_c_shared_utility/threadapi.h"
#include "azure_c_shared_utility/platform.h"
#include "parson.h"

Określanie zachowania urządzenia IoT

Biblioteka kliencka serializatora usługi IoT Hub korzysta z modelu do określania formatu komunikatów wymienianych między urządzeniem a usługą IoT Hub.

Dodaj następujące deklaracje zmiennych po instrukcji #include. Zastąp wartości zastępcze [Identyfikator urządzenia] i [Klucz urządzenia] wartościami zanotowaną dla urządzenia na pulpicie nawigacyjnym rozwiązania do monitorowania zdalnego. Użyj nazwy hosta usługi IoT Hub z pulpitu nawigacyjnego rozwiązania w celu zastąpienia wartości zastępczej [Nazwa usługi IoTHub]. Jeśli na przykład host usługi IoT Hub ma nazwę contoso.azure-devices.net, zastąp wartość zastępczą [Nazwa usługi IoTHub] ciągiem contoso:
```
static const char* deviceId = "[Device Id]";
static const char* connectionString = "HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]";
```

Dodaj następujący kod w celu zdefiniowania modelu umożliwiającego komunikację między urządzeniem a usługą IoT Hub. Ten model określa następujące właściwości urządzenia:

Może wysyłać dane telemetryczne dotyczące temperatury, temperatury zewnętrznej, wilgotności i identyfikatora urządzenia.
Może wysyłać metadane dotyczące urządzenia do usługi IoT Hub. Podczas uruchamiania urządzenie wysyła podstawowe metadane w obiekcie DeviceInfo.
Może wysyłać zgłaszane właściwości do bliźniaczej reprezentacji urządzenia w usłudze IoT Hub. Te zgłaszane właściwości są podzielone na następujące grupy: właściwości konfiguracji, urządzeń i systemu.
Może odbierać i przetwarzać żądane właściwości ustawione w bliźniaczej reprezentacji urządzenia w usłudze IoT Hub.
Może odpowiadać na bezpośrednie metody Reboot i InitiateFirmwareUpdate wywoływane za pośrednictwem portalu rozwiązania. Urządzenie wysyła informacje dotyczące obsługiwanych metod bezpośrednich za pomocą zgłaszanych właściwości.

// Define the Model
BEGIN_NAMESPACE(Contoso);

/* Reported properties */
DECLARE_STRUCT(SystemProperties,
  ascii_char_ptr, Manufacturer,
  ascii_char_ptr, FirmwareVersion,
  ascii_char_ptr, InstalledRAM,
  ascii_char_ptr, ModelNumber,
  ascii_char_ptr, Platform,
  ascii_char_ptr, Processor,
  ascii_char_ptr, SerialNumber
);

DECLARE_STRUCT(LocationProperties,
  double, Latitude,
  double, Longitude
);

DECLARE_STRUCT(ReportedDeviceProperties,
  ascii_char_ptr, DeviceState,
  LocationProperties, Location
);

DECLARE_MODEL(ConfigProperties,
  WITH_REPORTED_PROPERTY(double, TemperatureMeanValue),
  WITH_REPORTED_PROPERTY(uint8_t, TelemetryInterval)
);

/* Part of DeviceInfo */
DECLARE_STRUCT(DeviceProperties,
  ascii_char_ptr, DeviceID,
  _Bool, HubEnabledState
);

DECLARE_DEVICETWIN_MODEL(Thermostat,
  /* Telemetry (temperature, external temperature and humidity) */
  WITH_DATA(double, Temperature),
  WITH_DATA(double, ExternalTemperature),
  WITH_DATA(double, Humidity),
  WITH_DATA(ascii_char_ptr, DeviceId),

  /* DeviceInfo */
  WITH_DATA(ascii_char_ptr, ObjectType),
  WITH_DATA(_Bool, IsSimulatedDevice),
  WITH_DATA(ascii_char_ptr, Version),
  WITH_DATA(DeviceProperties, DeviceProperties),

  /* Device twin properties */
  WITH_REPORTED_PROPERTY(ReportedDeviceProperties, Device),
  WITH_REPORTED_PROPERTY(ConfigProperties, Config),
  WITH_REPORTED_PROPERTY(SystemProperties, System),

  WITH_DESIRED_PROPERTY(double, TemperatureMeanValue, onDesiredTemperatureMeanValue),
  WITH_DESIRED_PROPERTY(uint8_t, TelemetryInterval, onDesiredTelemetryInterval),

  /* Direct methods implemented by the device */
  WITH_METHOD(Reboot),
  WITH_METHOD(InitiateFirmwareUpdate, ascii_char_ptr, FwPackageURI),

  /* Register direct methods with solution portal */
  WITH_REPORTED_PROPERTY(ascii_char_ptr_no_quotes, SupportedMethods)
);

END_NAMESPACE(Contoso);

Implementowanie zachowania urządzenia

Teraz można dodać kod, który implementuje zachowanie zdefiniowane w modelu.

Dodaj następujące funkcje obsługujące żądane właściwości ustawione na pulpicie nawigacyjnym rozwiązania. Te żądane właściwości są zdefiniowane w modelu:

void onDesiredTemperatureMeanValue(void* argument)
{
  /* By convention 'argument' is of the type of the MODEL */
  Thermostat* thermostat = argument;
  printf("Received a new desired_TemperatureMeanValue = %f\r\n", thermostat->TemperatureMeanValue);

}

void onDesiredTelemetryInterval(void* argument)
{
  /* By convention 'argument' is of the type of the MODEL */
  Thermostat* thermostat = argument;
  printf("Received a new desired_TelemetryInterval = %d\r\n", thermostat->TelemetryInterval);
}

Dodaj następujące funkcje obsługujące bezpośrednie metody wywoływane za pośrednictwem usługi IoT Hub. Te metody bezpośrednie są zdefiniowane w modelu:

/* Handlers for direct methods */
METHODRETURN_HANDLE Reboot(Thermostat* thermostat)
{
  (void)(thermostat);

  METHODRETURN_HANDLE result = MethodReturn_Create(201, "\"Rebooting\"");
  printf("Received reboot request\r\n");
  return result;
}

METHODRETURN_HANDLE InitiateFirmwareUpdate(Thermostat* thermostat, ascii_char_ptr FwPackageURI)
{
  (void)(thermostat);

  METHODRETURN_HANDLE result = MethodReturn_Create(201, "\"Initiating Firmware Update\"");
  printf("Recieved firmware update request. Use package at: %s\r\n", FwPackageURI);
  return result;
}

Dodaj następującą funkcję, która wysyła komunikat do wstępnie skonfigurowanego rozwiązania:

/* Send data to IoT Hub */
static void sendMessage(IOTHUB_CLIENT_HANDLE iotHubClientHandle, const unsigned char* buffer, size_t size)
{
  IOTHUB_MESSAGE_HANDLE messageHandle = IoTHubMessage_CreateFromByteArray(buffer, size);
  if (messageHandle == NULL)
  {
    printf("unable to create a new IoTHubMessage\r\n");
  }
  else
  {
    if (IoTHubClient_SendEventAsync(iotHubClientHandle, messageHandle, NULL, NULL) != IOTHUB_CLIENT_OK)
    {
      printf("failed to hand over the message to IoTHubClient");
    }
    else
    {
      printf("IoTHubClient accepted the message for delivery\r\n");
    }

    IoTHubMessage_Destroy(messageHandle);
  }
  free((void*)buffer);
}

Dodaj następujący program obsługi wywołania zwrotnego, który jest uruchamiany, gdy urządzenie wyśle nowe wartości zgłaszanych właściwości do wstępnie skonfigurowanego rozwiązania:

/* Callback after sending reported properties */
void deviceTwinCallback(int status_code, void* userContextCallback)
{
  (void)(userContextCallback);
  printf("IoTHub: reported properties delivered with status_code = %u\n", status_code);
}

Dodaj następującą funkcję, aby połączyć urządzenie ze wstępnie skonfigurowanym rozwiązaniem w chmurze i rozpocząć wymianę danych. Ta funkcja wykonuje następujące działania:

Inicjuje platformę.
Rejestruje przestrzeń nazw Contoso z biblioteką serializacji.
Inicjuje klienta za pomocą parametrów połączenia urządzenia.
Tworzy wystąpienie modelu Thermostat.
Tworzy i wysyła zgłaszane wartości właściwości.
Wysyła obiekt DeviceInfo.
Tworzy pętlę wysyłającą dane telemetryczne co sekundę.
Wyłącza wszystkie zasoby.

void remote_monitoring_run(void)
{
  if (platform_init() != 0)
  {
    printf("Failed to initialize the platform.\n");
  }
  else
  {
    if (SERIALIZER_REGISTER_NAMESPACE(Contoso) == NULL)
    {
      printf("Unable to SERIALIZER_REGISTER_NAMESPACE\n");
    }
    else
    {
      IOTHUB_CLIENT_HANDLE iotHubClientHandle = IoTHubClient_CreateFromConnectionString(connectionString, MQTT_Protocol);
      if (iotHubClientHandle == NULL)
      {
        printf("Failure in IoTHubClient_CreateFromConnectionString\n");
      }
      else
      {
#ifdef MBED_BUILD_TIMESTAMP
        // For mbed add the certificate information
        if (IoTHubClient_SetOption(iotHubClientHandle, "TrustedCerts", certificates) != IOTHUB_CLIENT_OK)
        {
            printf("Failed to set option \"TrustedCerts\"\n");
        }
#endif // MBED_BUILD_TIMESTAMP
        Thermostat* thermostat = IoTHubDeviceTwin_CreateThermostat(iotHubClientHandle);
        if (thermostat == NULL)
        {
          printf("Failure in IoTHubDeviceTwin_CreateThermostat\n");
        }
        else
        {
          /* Set values for reported properties */
          thermostat->Config.TemperatureMeanValue = 55.5;
          thermostat->Config.TelemetryInterval = 3;
          thermostat->Device.DeviceState = "normal";
          thermostat->Device.Location.Latitude = 47.642877;
          thermostat->Device.Location.Longitude = -122.125497;
          thermostat->System.Manufacturer = "Contoso Inc.";
          thermostat->System.FirmwareVersion = "2.22";
          thermostat->System.InstalledRAM = "8 MB";
          thermostat->System.ModelNumber = "DB-14";
          thermostat->System.Platform = "Plat 9.75";
          thermostat->System.Processor = "i3-7";
          thermostat->System.SerialNumber = "SER21";
          /* Specify the signatures of the supported direct methods */
          thermostat->SupportedMethods = "{\"Reboot\": \"Reboot the device\", \"InitiateFirmwareUpdate--FwPackageURI-string\": \"Updates device Firmware. Use parameter FwPackageURI to specify the URI of the firmware file\"}";

          /* Send reported properties to IoT Hub */
          if (IoTHubDeviceTwin_SendReportedStateThermostat(thermostat, deviceTwinCallback, NULL) != IOTHUB_CLIENT_OK)
          {
            printf("Failed sending serialized reported state\n");
          }
          else
          {
            printf("Send DeviceInfo object to IoT Hub at startup\n");

            thermostat->ObjectType = "DeviceInfo";
            thermostat->IsSimulatedDevice = 0;
            thermostat->Version = "1.0";
            thermostat->DeviceProperties.HubEnabledState = 1;
            thermostat->DeviceProperties.DeviceID = (char*)deviceId;

            unsigned char* buffer;
            size_t bufferSize;

            if (SERIALIZE(&buffer, &bufferSize, thermostat->ObjectType, thermostat->Version, thermostat->IsSimulatedDevice, thermostat->DeviceProperties) != CODEFIRST_OK)
            {
              (void)printf("Failed serializing DeviceInfo\n");
            }
            else
            {
              sendMessage(iotHubClientHandle, buffer, bufferSize);
            }

            /* Send telemetry */
            thermostat->Temperature = 50;
            thermostat->ExternalTemperature = 55;
            thermostat->Humidity = 50;
            thermostat->DeviceId = (char*)deviceId;

            while (1)
            {
              unsigned char*buffer;
              size_t bufferSize;

              (void)printf("Sending sensor value Temperature = %f, Humidity = %f\n", thermostat->Temperature, thermostat->Humidity);

              if (SERIALIZE(&buffer, &bufferSize, thermostat->DeviceId, thermostat->Temperature, thermostat->Humidity, thermostat->ExternalTemperature) != CODEFIRST_OK)
              {
                (void)printf("Failed sending sensor value\r\n");
              }
              else
              {
                sendMessage(iotHubClientHandle, buffer, bufferSize);
              }

              ThreadAPI_Sleep(1000);
            }

            IoTHubDeviceTwin_DestroyThermostat(thermostat);
          }
        }
        IoTHubClient_Destroy(iotHubClientHandle);
      }
      serializer_deinit();
    }
  }
  platform_deinit();
}

Do celów referencyjnych zamieszczono tutaj przykładowy komunikat z danymi telemetrycznymi wysłany do wstępnie skonfigurowanego rozwiązania:

{"DeviceId":"mydevice01", "Temperature":50, "Humidity":50, "ExternalTemperature":55}

Wywoływanie funkcji remote_monitoring_run

W edytorze tekstów otwórz plik remote_monitoring.h . Dodaj następujący kod:

void remote_monitoring_run(void);

W edytorze tekstów otwórz plik main.c . Dodaj następujący kod:

#include "remote_monitoring.h"

int main(void)
{
    remote_monitoring_run();

    return 0;
}

Kompilowanie i uruchamianie aplikacji

W poniższych krokach opisano sposób kompilowania aplikacji klienckiej przy użyciu narzędzia CMake .

W edytorze tekstów otwórz plik CMakeLists.txt w folderze remote_monitoring .

Dodaj następujące instrukcje, aby zdefiniować sposób kompilowania aplikacji klienckiej:

macro(compileAsC99)
  if (CMAKE_VERSION VERSION_LESS "3.1")
    if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
      set (CMAKE_C_FLAGS "--std=c99 ${CMAKE_C_FLAGS}")
      set (CMAKE_CXX_FLAGS "--std=c++11 ${CMAKE_CXX_FLAGS}")
    endif()
  else()
    set (CMAKE_C_STANDARD 99)
    set (CMAKE_CXX_STANDARD 11)
  endif()
endmacro(compileAsC99)

cmake_minimum_required(VERSION 2.8.11)
compileAsC99()

set(AZUREIOT_INC_FOLDER "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/parson" "/usr/include/azureiot" "/usr/include/azureiot/inc")

include_directories(${AZUREIOT_INC_FOLDER})

set(sample_application_c_files
    ./parson/parson.c
    ./remote_monitoring.c
    ./main.c
)

set(sample_application_h_files
    ./parson/parson.h
    ./remote_monitoring.h
)

add_executable(sample_app ${sample_application_c_files} ${sample_application_h_files})

target_link_libraries(sample_app
    serializer
    iothub_client
    iothub_client_mqtt_transport
    aziotsharedutil
    umqtt
    pthread
    curl
    ssl
    crypto
    m
)

W folderze remote_monitoring utwórz folder do przechowywania plików make generowanych przez narzędzie CMake, a następnie uruchom polecenie cmake i wykonaj następujące polecenia:
```
mkdir cmake
cd cmake
cmake ../
make
```
Uruchom aplikację kliencą i wyślij dane telemetryczne do IoT Hub:
```
./sample_app
```

Wyświetlanie danych telemetrycznych z urządzeń na pulpicie nawigacyjnym

Pulpit nawigacyjny w rozwiązaniu do monitorowania zdalnego umożliwia wyświetlenie danych telemetrycznych wysyłanych z Twoich urządzeń do usługi IoT Hub.

W przeglądarce powróć do pulpitu nawigacyjnego rozwiązania do monitorowania zdalnego i kliknij pozycję Urządzenia w lewym panelu, aby przejść do listy urządzeń.
Na liście urządzeń powinien być widoczny stan urządzenia Uruchomione. W przeciwnym razie kliknij pozycję Włącz urządzenie w panelu Szczegóły urządzenia.
Kliknij pozycję Pulpit nawigacyjny, aby powrócić do pulpitu nawigacyjnego, a następnie wybierz swoje urządzenie z listy rozwijanej Urządzenie do wyświetlenia, aby wyświetlić z niego dane telemetryczne. Dane telemetryczne z przykładowej aplikacji to 50 jednostek temperatury wewnętrznej, 55 — temperatury zewnętrznej i 50 — wilgotności.

Wywoływanie metody na urządzeniu

Pulpit nawigacyjny w rozwiązaniu do monitorowania zdalnego umożliwia wywoływanie metod na urządzaniach za pomocą usługi IoT Hub. W rozwiązaniu do monitorowania zdalnego możesz na przykład wywołać metodę symulacji ponownego uruchomienia urządzenia.

Na pulpicie nawigacyjnym rozwiązania do monitorowania zdalnego kliknij pozycję Urządzenia w lewym panelu, aby przejść do listy urządzeń.
Kliknij pozycję Identyfikator urządzenia dla swojego urządzenia na liście urządzeń.
W panelu Szczegóły urządzenia kliknij pozycję Metody.
Na liście rozwijanej Metoda wybierz metodę InitiateFirmwareUpdate (inicjowanie aktualizacji oprogramowania układowego), a następnie w polu FWPACKAGEURI (identyfikator URI pakietu oprogramowania układowego) wprowadź zastępczy adres URL. Kliknij pozycję Wywołaj metodę, aby wywołać metodę na urządzeniu.
Gdy urządzenie obsłuży metodę, zostanie wyświetlony komunikat w konsoli uruchamiania kodu urządzenia. Wyniki metody zostaną dodane do historii w portalu rozwiązania:

Następne kroki

W artykule Dostosowywanie wstępnie skonfigurowanych rozwiązań opisano niektóre sposoby pozwalające rozszerzyć ten przykład. Możliwe rozszerzenia obejmują użycie rzeczywistych czujników i implementację dodatkowych poleceń.

Więcej informacji na temat uprawnień podano w witrynie azureiotsuite.com.

Udostępnij za pośrednictwem