Připojení zařízení k předkonfigurovanýmu řešení vzdáleného monitorování (Windows)

Přehled scénáře

V tomto scénáři vytvoříte zařízení, které odešle následující telemetrii do předkonfigurovaného řešení vzdáleného monitorování:

Vnější teplota
Vnitřní teplota
Vlhkost

Kód na zařízení pro zjednodušení generuje ukázkové hodnoty, ale doporučujeme, abyste ukázku rozšířili připojením skutečných senzorů k zařízení a odesláním skutečné telemetrie.

Zařízení také dokáže reagovat na metody vyvolané z řídicího panelu řešení a požadovaných hodnot vlastností nastavených na řídicím panelu řešení.

K dokončení tohoto kurzu potřebujete aktivní účet Azure. Během několika minut si můžete vytvořit bezplatný zkušební účet, pokud ho ještě nemáte. Podrobnosti najdete v článku Bezplatná zkušební verze Azure.

Než začnete

Než napíšete jakýkoli kód pro vaše zařízení, musíte zřídit předkonfigurované řešení vzdáleného monitorování a zřídit nové vlastní zařízení v daném řešení.

Zřízení předkonfigurovaného řešení vzdáleného monitorování

Zařízení, které vytvoříte v tomto kurzu, odesílá data do instance vzdáleného monitorování předkonfigurovaného řešení. Pokud jste ještě ve svém účtu Azure nezřídili předkonfigurované řešení vzdáleného monitorování, postupujte následovně:

Na stránce https://www.azureiotsolutions.com/ kliknutím na + vytvořte řešení.
Klikněte na Vybrat na panelu vzdáleného monitorování pro vytvoření vašeho řešení.
Na stránce Vytvořit řešení pro vzdálené monitorování zadejte název řešení podle svého výběru, vyberte oblast, do které chcete nasadit, a vyberte předplatné Azure, které chcete použít. Potom klikněte na Vytvořit řešení.
Počkejte, až se proces zřizování dokončí.

Výstraha

Předkonfigurovaná řešení používají fakturovatelné služby Azure. Předkonfigurované řešení z vašeho předplatného nezapomeňte odebrat, abyste se vyhnuli zbytečným poplatkům. Předkonfigurované řešení můžete z předplatného úplně odebrat na stránce https://www.azureiotsolutions.com/.

Po dokončení procesu zřizování řešení pro vzdálené monitorování kliknutím na Spustit otevřete řídicí panel řešení v prohlížeči.

Solution dashboard Řídicí panel řešení

Nakonfigurujte své zařízení v řešení pro vzdálené monitorování

Poznámka:

Pokud jste už ve svém řešení zřídili zařízení, můžete tento krok přeskočit. Při vytváření klientské aplikace potřebujete znát přihlašovací údaje zařízení.

Aby se zařízení mohlo připojit k předkonfigurovanýmu řešení, musí se k IoT Hubu identifikovat pomocí platných přihlašovacích údajů. Přihlašovací údaje zařízení můžete načíst z řídicího panelu řešení. Přihlašovací údaje zařízení zahrnete do klientské aplikace později v tomto kurzu.

Pokud chcete přidat zařízení do řešení pro vzdálené monitorování, proveďte na řídicím panelu řešení následující kroky:

V levém dolním rohu řídicího panelu klikněte na Přidat zařízení.
Na panelu Vlastní zařízení klikněte na Přidat nové.

zařízení
Zvolte Umožnit mi definovat vlastní ID zařízení. Zadejte ID zařízení, jako například mydevice, klikněte na Kontrola ID, abyste ověřili, že název již není používán, a následně klikněte na Vytvořit pro zřízení zařízení.
Poznamenejte si přihlašovací údaje zařízení (ID zařízení, název hostitele služby IoT Hub a klíč zařízení). Vaše klientská aplikace potřebuje tyto hodnoty pro připojení k řešení pro vzdálené monitorování. Potom klikněte na Done (Hotovo).
Vyberte zařízení v seznamu zařízení na řídicím panelu řešení. Potom na panelu Podrobnosti o zařízení klepněte na Povolit zařízení. Stav zařízení je nyní v provozu. Řešení pro vzdálené monitorování teď může přijímat telemetrická data z vašeho zařízení a vyvolávat metody v zařízení.

Vytvoření ukázkového řešení jazyka C ve Windows

Následující kroky ukazují, jak vytvořit klientskou aplikaci, která komunikuje s předkonfigurovaným řešením vzdáleného monitorování. Tato aplikace je napsaná v jazyce C a je vytvořená a spuštěná ve Windows.

Vytvořte startovací projekt v sadě Visual Studio 2015 nebo Visual Studio 2017 a přidejte si balíčky NuGet klienta zařízení IoT Hubu.

V sadě Visual Studio vytvořte konzolovou aplikaci jazyka C pomocí šablony konzolové aplikace Visual C++ Win32 . Pojmenujte projekt RMDevice.
Na stránce Nastavení aplikace v Průvodci aplikací Win32 se ujistěte, že je vybraná konzolová aplikace, a zrušte zaškrtnutí políčka Předkompilované hlavičky a SDL (Security Development Lifecycle).
V Průzkumníku řešení odstraňte soubory stdafx.h, targetver.h a stdafx.cpp.
V Průzkumníku řešení přejmenujte soubor RMDevice.cpp na RMDevice.c.
V Průzkumníku řešení klikněte pravým tlačítkem na projekt RMDevice a potom klikněte na Spravovat balíčky NuGet. Klikněte na Procházet, vyhledejte a nainstalujte následující balíčky NuGet:
- Microsoft.Azure.IoTHub.Serializer
- Microsoft.Azure.IoTHub.IoTHubClient
- Microsoft.Azure.IoTHub.MqttTransport
V Průzkumníku řešení klikněte pravým tlačítkem myši na projekt RMDevice a potom kliknutím na Vlastnosti otevřete dialogové okno Stránky vlastností projektu. Podrobnosti naleznete v tématu Nastavení vlastností projektu jazyka Visual C++.
Klikněte na složku Linker a potom klikněte na stránku vlastností Vstup .
Přidejte crypt32.lib do vlastnosti Additional Dependencies . Kliknutím na tlačítko OK a dalším ok uložte hodnoty vlastností projektu.

Přidejte do projektu RMDevice knihovnu Parson JSON a přidejte požadované #include příkazy:

V vhodné složce na počítači naklonujte úložiště Parson GitHub pomocí následujícího příkazu:
```
git clone https://github.com/kgabis/parson.git
```
Zkopírujte soubory parson.h a parson.c z místní kopie úložiště Parson do složky projektu RMDevice .
V sadě Visual Studio klepněte pravým tlačítkem myši na projekt RMDevice , klepněte na tlačítko Přidat a potom klepněte na tlačítko Existující položka.
V dialogovém okně Přidat existující položku vyberte soubory parson.h a parson.c ve složce projektu RMDevice . Potom kliknutím na Přidat tyto dva soubory do projektu.

V sadě Visual Studio otevřete soubor RMDevice.c. #include Existující příkazy nahraďte následujícím kódem:

#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"

Poznámka:

Teď můžete ověřit, jestli má váš projekt nastavené správné závislosti, a to tak, že ho vytvoříte.

Určení chování zařízení IoT

Klientská knihovna serializátoru IoT Hub používá model k určení formátu zpráv, které zařízení vyměňuje se službou IoT Hub.

Za příkazy #include přidejte následující deklarace proměnných. Zástupné hodnoty [ID zařízení] a [Klíč zařízení] nahraďte hodnotami, které jste si poznamenali pro své zařízení na řídicím panelu řešení pro vzdálené monitorování. Pomocí názvu hostitele služby IoT Hub z řídicího panelu řešení nahraďte [IoTHub Name]. Pokud je například název hostitele služby IoT Hub contoso.azure-devices.net, nahraďte [IoTHub Name] contoso:
```
static const char* deviceId = "[Device Id]";
static const char* connectionString = "HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]";
```

Přidejte následující kód, který definuje model, který umožňuje zařízení komunikovat se službou IoT Hub. Tento model určuje, že zařízení:

Může posílat jako telemetrii teplotu, externí teplotu, vlhkost a ID zařízení.
Může odesílat metadata o zařízení do IoT Hubu. Zařízení odesílá základní metadata v objektu DeviceInfo při spuštění.
Může odesílat ohlášené vlastnosti do dvojčete zařízení ve službě IoT Hub. Tyto ohlášené vlastnosti jsou seskupené do vlastností konfigurace, zařízení a systému.
Může přijímat a pracovat s požadovanými vlastnostmi nastavenými ve dvojčeti zařízení ve službě IoT Hub.
Může reagovat na přímé metody vyvolané prostřednictvím portálu řešení: Restartování a ZahájeníAktualizaceFirmwaru. Zařízení odesílá informace o přímých metodách, které podporuje, pomocí ohlášených vlastností.

// 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);

Implementace chování zařízení

Teď přidejte kód, který implementuje chování definované v modelu.

Přidejte následující funkce, které zpracovávají požadované vlastnosti nastavené na řídicím panelu řešení. V modelu jsou definovány tyto požadované vlastnosti:

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);
}

Přidejte následující funkce, které zpracovávají přímé metody vyvolané prostřednictvím centra IoT. Tyto přímé metody jsou definovány v 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;
}

Přidejte následující funkci, která odešle zprávu do předkonfigurovaného řešení:

/* 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);
}

Přidejte následující obslužnou rutinu zpětného volání, která se spustí, když zařízení do předkonfigurovaného řešení odeslalo nové hlášené hodnoty vlastností:

/* 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);
}

Přidejte následující funkci pro připojení zařízení k předkonfigurovanýmu řešení v cloudu a výměnu dat. Tato funkce provádí následující kroky:

Inicializuje platformu.
Zaregistruje obor názvů Contoso v serializační knihovně.
Inicializuje klienta připojovacím řetězcem zařízení.
Vytvořte instanci modelu termostatu.
Vytvoří a odešle hlášené hodnoty vlastností.
Odešle objekt DeviceInfo.
Vytvoří smyčku pro odesílání telemetrie každou sekundu.
Deinicializuje všechny prostředky.

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();
}

Tady je ukázka zprávy telemetrie, odeslané do předkonfigurovaného řešení:

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

Sestavení a spuštění ukázky

Přidejte kód pro vyvolání funkce remote_monitoring_run a pak sestavte a spusťte aplikaci zařízení.

Nahraďte hlavní funkci následujícím kódem, který vyvolá funkci remote_monitoring_run :
```
int main()
{
  remote_monitoring_run();
  return 0;
}
```
Kliknutím na Sestavit a pak Sestavit řešení sestavte aplikaci zařízení.
V Průzkumníku řešení klikněte pravým tlačítkem myši na projekt RMDevice , klepněte na příkaz Ladit a potom klepněte na tlačítko Spustit novou instanci a spusťte ukázku. Konzola zobrazí zprávy, když aplikace odesílá ukázkovou telemetrii do předkonfigurovaného řešení, přijímá hodnoty požadovaných vlastností nastavené na řídicím panelu řešení a reaguje na metody vyvolané z řídicího panelu řešení.

Zobrazení telemetrie zařízení na řídicím panelu

Řídicí panel v řešení pro vzdálené monitorování umožňuje zobrazit telemetrická data odesílaná do IoT Hubu.

V prohlížeči se vraťte na řídicí panel řešení pro vzdálené monitorování, klikněte na Zařízení na levém panelu a přejděte do seznamu Zařízení.
V seznamu zařízení byste měli vidět, že stav vašeho zařízení je spuštěný. Pokud ne, klikněte na Povolit zařízení v panelu Podrobnosti o zařízení.
Klikněte na Řídicí panel pro návrat na řídicí panel, vyberte své zařízení v rozevíracím seznamu Zařízení k zobrazení pro zobrazení jeho telemetrie. Telemetrie z ukázkové aplikace je 50 jednotek pro vnitřní teplotu, 55 jednotek pro vnější teplotu a 50 jednotek pro vlhkost.

Vyvolání metody na vašem zařízení

Řídicí panel v řešení pro vzdálené monitorování umožňuje vyvolat metody na vašich zařízeních prostřednictvím IoT Hubu. Například v řešení pro vzdálené monitorování můžete vyvolat metodu pro simulaci restartování zařízení.

Na řídicím panelu řešení pro vzdálené monitorování klikněte na Zařízení na levém panelu a přejděte na seznam Zařízení.
Klikněte na Device ID pro vaše zařízení v seznamu zařízení .
Na panelu Podrobnosti o zařízení klepněte na Metody.
V rozevíracím seznamu Metoda vyberte InitiateFirmwareUpdatea potom v FWPACKAGEURI zadejte fiktivní adresu URL. Kliknutím na Vyvolat metodu zavoláte metodu v zařízení.
Zpráva se zobrazí v konzoli, když vaše zařízení spouští kód a zpracovává metodu. Výsledky metody se přidají do historie na portálu řešení:

Další kroky

Článek Přizpůsobení předkonfigurovaných řešení popisuje některé způsoby, jak tuto ukázku rozšířit. Mezi možná rozšíření patří použití skutečných senzorů a implementace dalších příkazů.

Další informace o oprávněních najdete na webu azureiotsuite.com.

Last updated on 2017-11-02

Sdílet prostřednictvím