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

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 části 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 předkonfigurovaného řešení vzdáleného monitorování . 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í.
Kliknutím na vybrat na panelu vzdáleného 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 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čí.

Varování

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ý.
Zvolte Povolit mi definovat vlastní ID zařízení. Zadejte ID zařízení, jako je mydevice, klikněte na tlačítko Zkontrolovat ID , abyste ověřili, že se název ještě nepoužívá, a potom kliknutím na vytvořit zřiďte 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 Hotovo.
Vyberte zařízení v seznamu zařízení na řídicím panelu řešení. Potom na panelu Podrobnosti o zařízení klepněte na tlačítko Povolit zařízení. Stav vašeho zařízení je teď 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í.

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 vytvořená 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í s 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 Hubu 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 klientskou knihovnu IoT Hubu a soubory hlaviček na počítači s Ubuntu:

V příkazovém řádku přidejte do počítače úložiště AzureIoT:

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 Služby IoT Hub používají analyzátor Parson JSON k analýze datových částí zpráv. 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á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] názvem 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 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í

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 Termostat .
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ázková zpráva telemetrie odeslaná do předkonfigurovaného řešení:

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

Zavolejte funkci 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řidáním následujících pokynů definujte, 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 ukládání souborů make, které CMake generuje, a pak spusťte příkazy cmake a make následujícím způsobem:
```
mkdir cmake
cd cmake
cmake ../
make
```
Spusťte klientskou aplikaci a odešlete telemetrii do IoT Hubu:
```
./sample_app
```

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í a kliknutím na Zařízení na levém panelu 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, klepněte na tlačítko Povolit zařízení na panelu Podrobnosti o zařízení .
Kliknutím na řídicí panel se vrátíte na řídicí panel, výběrem zařízení v rozevíracím seznamu Zařízení zobrazíte jeho telemetrii. 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 do seznamu Zařízení.
V seznamu Zařízení klikněte na ID zařízení.
Na panelu Podrobnosti o zařízení klikněte na Metody.
V rozevíracím seznamu Metoda vyberte InitiateFirmwareUpdate a pak v FWPACKAGEURI zadejte fiktivní adresu URL. Kliknutím na Vyvolat metodu volejte metodu na 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 na webu azureiotsuite.com.

Last updated on 2017-11-02

Sdílet prostřednictvím