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

Č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.

Sestavení a spuštění ukázkového klienta C v Linuxu

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á v Ubuntu Linuxu.

K provedení těchto kroků potřebujete zařízení s Ubuntu verze 15.04 nebo 15.10. Než budete pokračovat, nainstalujte na zařízení Ubuntu požadované balíčky pomocí následujícího příkazu:

sudo apt-get install cmake gcc g++

Instalace klientských knihoven na zařízení

Klientské knihovny Azure IoT Hub jsou k dispozici jako balíček, který můžete nainstalovat na zařízení s Ubuntu pomocí příkazu apt-get. Následujícím postupem nainstalujte balíček, který obsahuje IoT Hub klientskou knihovnu a soubory hlaviček v počítači s Ubuntu:

Do prostředí přidejte úložiště AzureIoT do počítače:

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

Instalace balíčku azure-iot-sdk-c-dev

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

Instalace analyzátoru Parson JSON

Klientské knihovny IoT Hub k analýze datových částí zpráv používají analyzátor Parson JSON. 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

Příprava projektu

Na počítači s Ubuntu vytvořte složku s názvem remote_monitoring. Ve složce remote_monitoring :

Vytvořte čtyři soubory main.c, remote_monitoring.c, remote_monitoring.h a CMakeLists.txt.
Vytvořte složku s názvem parson.

Zkopírujte soubory parson.c a parson.h z místní kopie úložiště Parson do složky remote_monitoring/parson .

V textovém editoru otevřete soubor remote_monitoring.c . Přidejte následující příkazy #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"

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}

Volání funkce remote_monitoring_run

V textovém editoru otevřete soubor remote_monitoring.h . Přidejte následující kód:

void remote_monitoring_run(void);

V textovém editoru otevřete soubor main.c . Přidejte následující kód:

#include "remote_monitoring.h"

int main(void)
{
    remote_monitoring_run();

    return 0;
}

Sestavení a spuštění aplikace

Následující kroky popisují, jak pomocí CMake sestavit klientskou aplikaci.

V textovém editoru otevřete soubor CMakeLists.txt ve složce remote_monitoring .

Přidejte následující pokyny, které definují, jak sestavit klientskou aplikaci:

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
)

Ve složce remote_monitoring vytvořte složku pro uložení souborů , které CMake vygeneruje, a spusťte cmake a proveďte příkazy následujícím způsobem:
```
mkdir cmake
cd cmake
cmake ../
make
```
Spusťte klientskou aplikaci a odešlete telemetrii do IoT Hub:
```
./sample_app
```

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