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

Článek
11/02/2017

Přehled scénáře

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

Venkovní teplota
Vnitřní teplota
Vlhkost

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

Zařízení je také schopné odpovídat na metody vyvolané z řídicího panelu řešení a na požadované hodnoty vlastností nastavené na řídicím panelu řešení.

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

Než začnete

Než začnete psát kód pro zařízení, je nutné zřídit předkonfigurované řešení vzdáleného monitorování a v něm zřídit nové vlastní zařízení.

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

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

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

Upozornění

Předkonfigurovaná řešení využívají fakturovatelné služby Azure. Abyste se vyhnuli zbytečným poplatkům, nezapomeňte předkonfigurované řešení odebrat ze svého předplatného, jakmile s ním budete hotovi. Předkonfigurované řešení můžete z předplatného úplně odebrat tak https://www.azureiotsolutions.com/ , že navštívíte stránku.

Po skončení procesu zřizování řešení pro vzdálené monitorování klikněte na Spustit. Ve vašem prohlížeči se otevře řídicí panel řešení.

Řídicí panel řešení

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

Poznámka

Pokud jste už ve svém řešení zařízení zřídili, 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 identifikovat ve službě IoT Hub pomocí platných přihlašovacích údajů. Přihlašovací údaje zařízení můžete zjistit z řídicího panelu řešení. Přihlašovací údaje zařízení vložíte 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é.
Vyberte možnost Definovat vlastní ID zařízení. Zadejte ID zařízení, třeba mydevice, klikněte na Zkontrolovat ID pro ověření, že se tento název ještě nepoužívá, a potom zřiďte zařízení kliknutím na Vytvořit.
Poznamenejte si přihlašovací údaje zařízení (ID zařízení, název hostitele služby IoT Hub a Klíč zařízení). Klientská aplikace potřebuje tyto hodnoty pro připojení k řešení pro vzdálené monitorování. Potom klikněte na Hotovo.
V seznamu zařízení na řídicím panelu řešení vyberte své zařízení. Pak na panelu Podrobnosti o zařízení klikněte na Povolit zařízení. Stav vašeho zařízení je teď Spuštěno. Řešení pro vzdálené monitorování teď může z vašeho zařízení přijímat telemetrii a vyvolávat v něm metody.

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 sestavená a spuštěná ve Windows.

Vytvořte počáteční projekt v sadě Visual Studio 2015 nebo Visual Studio 2017 a přidejte balíčky NuGet klienta zařízení IoT Hub:

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í předkompilované hlavičky a kontroly SDL (Security Development Lifecycle).
V Průzkumník řešení odstraňte soubory stdafx.h, targetver.h a stdafx.cpp.
V Průzkumník řešení přejmenujte soubor RMDevice.cpp na RMDevice.c.
V Průzkumník řešení klikněte pravým tlačítkem myši na projekt RMDevice a potom klikněte na Spravovat balíčky NuGet. Klikněte na Procházet a vyhledejte a nainstalujte následující balíčky NuGet:
- Microsoft.Azure.IoTHub.Serializer
- Microsoft.Azure.IoTHub.IoTHubClient
- Microsoft.Azure.IoTHub.MqttTransport
V Průzkumník řešení klikněte pravým tlačítkem myši na projekt RMDevice a potom klepněte na příkaz Vlastnosti otevřete dialogové okno Stránky vlastností projektu. Podrobnosti najdete v tématu Nastavení vlastností projektu 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 . Chcete-li uložit hodnoty vlastností projektu, klikněte na tlačítko OK a potom znovu na tlačítko OK .

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 klikněte pravým tlačítkem myši na projekt RMDevice , klepněte na tlačítko Přidat a poté klepněte na položku Existující.
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 přidejte tyto dva soubory do projektu.

V sadě Visual Studio otevřete soubor RMDevice.c. Nahraďte existující #include příkazy 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.

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

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

Přidejte následující deklarace proměnných za příkazy #include. Nahraďte zástupné hodnoty [ID zařízení] a [Klíč zařízení] hodnotami, které jste si poznamenali pro své zařízení na řídicím panelu řešení pro vzdálené monitorování. K nahrazení hodnoty [IoTHub Name] (Název služby IoT Hub) použijte název hostitele služby IoT Hub z řídicího panelu řešení. Pokud je například název hostitele vaší služby IoT Hub contoso.azure-devices.net, nahraďte hodnotu [IoTHub Name] za 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 definující model, který umožní komunikaci zařízení se službou IoT Hub. Tento model určuje, že zařízení:

Může odesílat teplotu, externí teplotu, vlhkost a ID zařízení jako telemetrii.
Může odesílat metadata o zařízení do služby IoT Hub. Zařízení při spuštění odesílá základní metadata v objektu DeviceInfo.
Může odesílat ohlášené vlastnosti do dvojčete zařízení ve službě IoT Hub. Tyto ohlášené vlastnosti se seskupují do vlastností konfigurace, zařízení a systému.
Může přijímat požadované vlastnosti nastavené ve dvojčeti zařízení ve službě IoT Hub a jednat podle nich.
Může reagovat na přímé metody Reboot a InitiateFirmwareUpdate vyvolané prostřednictvím portálu řešení. 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í

Nyní 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í. Tyto požadované vlastnosti jsou definované v 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);
}

Přidejte následující funkce, které zpracovávají přímé metody vyvolané prostřednictvím služby IoT Hub. Tyto přímé metody jsou definované 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á odesílá 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í obsluhu zpětného volání, která se spustí, když zařízení do předkonfigurovaného řešení odešle nové hodnoty požadovaných 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, která vaše zařízení připojí k předkonfigurovanému řešení v cloudu a umožní výměnu dat. Tato funkce provádí následující kroky:

Inicializuje platformu.
Zaregistruje v knihovně serializace obor názvů Contoso.
Inicializuje klienta s připojovacím řetězcem zařízení.
Vytvoří instanci modelu Thermostat.
Vytvoří a odešle hodnoty ohlášených vlastností.
Odešle objekt DeviceInfo.
Vytvoří smyčku pro odesílání telemetrie každou sekundu.
Uvolní 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 pro srovnání ukázková zpráva 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;
}
```
Klikněte na Sestavit a pak sestavit řešení a sestavte aplikaci zařízení.
V Průzkumník řešení klikněte pravým tlačítkem myši na projekt RMDevice, klepněte na tlačítko Ladění a klepněte na tlačítko Spustit novou instanci spustit ukázku. Konzola zobrazí zprávy, protože aplikace odesílá ukázkovou telemetrii do předkonfigurovaného řešení, přijímá požadované hodnoty 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 řešení pro vzdálené monitorování umožňuje zobrazit telemetrická data, která vaše zařízení odesílají do IoT Hubu.

V prohlížeči se vraťte na řídicí panel řešení pro vzdálené monitorování a kliknutím na Zařízení na levém panelu přejděte k seznamu zařízení.
V seznamu zařízení by se mělo zobrazit, že zařízení je ve stavu Spuštěno. Pokud ne, na panelu Podrobnosti o zařízení klikněte na Povolit zařízení.
Kliknutím na Řídicí panel se vraťte na řídicí panel a v rozevíracím seznamu Zobrazit zařízení vyberte požadované zařízení. Zobrazí se jeho telemetrická data. Telemetrická data z ukázkové aplikace odpovídají 50 jednotkám pro vnitřní teplotu, 55 jednotkám pro venkovní teplotu a 50 jednotkám pro vlhkost.

Volání metody na zařízení

Řídicí panel řešení pro vzdálené monitorování umožňuje vyvolat na zařízení metody prostřednictvím IoT Hubu. V řešení pro vzdálené monitorování můžete třeba 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 k seznamu zařízení.
V seznamu zařízení klikněte na požadované ID zařízení.
Na panelu Podrobnosti o zařízení klikněte na Metody.
V rozevíracím seznamu Metoda vyberte InitiateFirmwareUpdate a potom do FWPACKAGEURI zadejte fiktivní adresu URL. Kliknutím na Vyvolat metodu vyvoláte tuto metodu na příslušném zařízení.
Když zařízení zpracovává tuto metodu, zobrazí se zpráva na konzole, kde je spuštěný kód vašeho zařízení. 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, kterými jde tuto ukázku rozšířit. Mezi možná rozšíření patří skutečné senzory a implementace dalších příkazů.

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

Sdílet prostřednictvím