Ansluta enheten till den förkonfigurerade fjärrövervakningslösningen (Linux)

Scenarioöversikt

I det här scenariot skapar du en enhet som skickar följande telemetri till den förkonfigurerade fjärrövervakningslösningen:

Yttre temperatur
Intern temperatur
Fuktighet

För enkelhetens skull genererar koden på enheten exempelvärden, men vi rekommenderar att du utökar exemplet genom att ansluta verkliga sensorer till enheten och skicka verklig telemetri.

Enheten kan också svara på metoder som anropas från lösningsinstrumentpanelen och önskade egenskapsvärden som angetts i instrumentpanelen för lösningen.

För att slutföra den här självstudien behöver du ett aktivt Azure-konto. Om du inte har något konto kan skapa du ett kostnadsfritt utvärderingskonto på bara några minuter. Mer information finns i kostnadsfri utvärderingsversion av Azure.

Innan du börjar

Innan du skriver någon kod för enheten måste du etablera den förkonfigurerade fjärrövervakningslösningen och etablera en ny anpassad enhet i den lösningen.

Etablera den förkonfigurerade fjärrövervakningslösningen

Enheten som du skapar i den här självstudien skickar data till en instans av den förkonfigurerade fjärrövervakningslösningen . Om du inte redan har etablerat den förkonfigurerade fjärrövervakningslösningen i ditt Azure-konto använder du följande steg:

På sidan https://www.azureiotsolutions.com/, klicka på + för att skapa en lösning.
Klicka på Välj på panelen Fjärrövervakning för att skapa din lösning.
På sidan Skapa fjärrövervakningslösning anger du ett lösningsnamn , väljer den region som du vill distribuera till och väljer den Azure-prenumeration som du vill använda. Klicka sedan på Skapa lösning.
Vänta tills etableringsprocessen är slutförd.

Varning

De förkonfigurerade lösningarna använder fakturerbara Azure-tjänster. Se till att ta bort den förkonfigurerade lösningen från din prenumeration när du är klar med den för att undvika onödiga avgifter. Du kan ta bort en förkonfigurerad lösning helt från din prenumeration genom att gå till sidan https://www.azureiotsolutions.com/ .

När etableringsprocessen för fjärrövervakningslösningen är klar klickar du på Starta för att öppna lösningsinstrumentpanelen i webbläsaren.

Instrumentpanel för lösning

Etablera enheten i fjärrövervakningslösningen

Anmärkning

Om du redan har etablerat en enhet i din lösning kan du hoppa över det här steget. Du måste känna till enhetens autentiseringsuppgifter när du skapar klientprogrammet.

För att en enhet ska kunna ansluta till den förkonfigurerade lösningen måste den identifiera sig för IoT Hub med giltiga autentiseringsuppgifter. Du kan hämta enhetens autentiseringsuppgifter från lösningens instrumentpanel. Du inkluderar autentiseringsuppgifterna för enheten i klientprogrammet senare i den här handledningen.

Utför följande steg på instrumentpanelen för lösningen för att lägga till en enhet i fjärrövervakningslösningen:

I det nedre vänstra hörnet på instrumentpanelen klickar du på Lägg till en enhet.
I panelen för Anpassad enhet klickar du på Lägg till nytt.
Välj Låt mig definiera mitt eget enhets-ID. Ange ett enhets-ID, till exempel mydevice, klicka på Kontrollera ID för att kontrollera att namnet inte redan används och klicka sedan på Skapa för att etablera enheten.
Anteckna enhetens autentiseringsuppgifter (enhets-ID, IoT Hub-värdnamn och enhetsnyckel). Klientprogrammet behöver dessa värden för att ansluta till fjärrövervakningslösningen. Klicka sedan på Done (Klar).
Välj enheten i enhetslistan på instrumentpanelen för lösningen. I panelen Enhetsinformation klickar du sedan på Aktivera enhet. Enhetens status är nu I drift. Fjärrövervakningslösningen kan nu ta emot telemetri från enheten och anropa metoder på enheten.

Skapa och köra ett exempel på C-klienten Linux

Följande steg visar hur du skapar ett klientprogram som kommunicerar med den förkonfigurerade fjärrövervakningslösningen. Det här programmet är skrivet i C och har skapats och körts på Ubuntu Linux.

För att slutföra de här stegen behöver du en enhet som kör Ubuntu version 15.04 eller 15.10. Innan du fortsätter installerar du de nödvändiga paketen på din Ubuntu-enhet med hjälp av följande kommando:

sudo apt-get install cmake gcc g++

Installera klientbiblioteken på enheten

Azure IoT Hub-klientbiblioteken är tillgängliga som ett paket som du kan installera på din Ubuntu-enhet med hjälp av kommandot apt-get . Utför följande steg för att installera paketet som innehåller IoT Hub-klientbiblioteket och huvudfilerna på Ubuntu-datorn:

I ett gränssnitt lägger du till AzureIoT-lagringsplatsen på datorn:

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

Installera paketet azure-iot-sdk-c-dev

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

Installera Parson JSON-parsern

IoT Hub-klientbiblioteken använder Parson JSON-parsern för att parsa meddelandenyttolaster. I en lämplig mapp på datorn klonar du Parson GitHub-lagringsplatsen med följande kommando:

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

Förbereda projektet

På din Ubuntu-dator skapar du en mapp med namnet remote_monitoring. I mappen remote_monitoring :

Skapa de fyra filerna main.c, remote_monitoring.c, remote_monitoring.h och CMakeLists.txt.
Skapa mapp med namnet parson.

Kopiera filerna parson.c och parson.h från din lokala kopia av Parson-lagringsplatsen till mappen remote_monitoring/parson .

Öppna filen remote_monitoring.c i en textredigerare. Lägg till följande #include-uttryck:

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

Ange beteendet för IoT-enheten

Klientbiblioteket för IoT Hub-serialiseraren använder en modell för att ange formatet för de meddelanden som enheten utbyter med IoT Hub.

Lägg till följande variabeldeklarationer efter #include-instruktionerna. Ersätt platshållarvärdena [Enhets-ID] och [Enhetsnyckel] med värden som du antecknade för enheten på instrumentpanelen för fjärrövervakningslösningen. Använd IoT Hub-värdnamnet från lösningsinstrumentpanelen för att ersätta [IoTHub Name]. Om ditt IoT Hub-värdnamn till exempel är contoso.azure-devices.net ersätter du [IoTHub Name] med contoso:
```
static const char* deviceId = "[Device Id]";
static const char* connectionString = "HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]";
```

Lägg till följande kod för att definiera den modell som gör att enheten kan kommunicera med IoT Hub. Den här modellen anger att enheten:

Kan skicka temperatur, extern temperatur, luftfuktighet och ett enhets-ID som telemetri.
Kan skicka metadata om enheten till IoT Hub. Enheten skickar grundläggande metadata i ett DeviceInfo-objekt vid start.
Kan skicka rapporterade egenskaper till enhetstvillingen i IoT Hub. Dessa rapporterade egenskaper grupperas i konfigurations-, enhets- och systemegenskaper.
Kan ta emot och agera på önskade egenskaper som angetts i enhetstvillingen i IoT Hub.
Kan svara på direktmetoderna Reboot och InitiateFirmwareUpdate som anropas via lösningsportalen. Enheten skickar information om de direkta metoder som den stöder med hjälp av rapporterade egenskaper.

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

Implementera enhetens beteende

Lägg nu till kod som implementerar det beteende som definierats i modellen.

Lägg till följande funktioner som hanterar önskade egenskaper som angetts på lösningsinstrumentpanelen. Dessa önskade egenskaper definieras i modellen:

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

Lägg till följande funktioner som hanterar de direkta metoder som anropas via IoT-hubben. Dessa direkta metoder definieras i modellen:

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

Lägg till följande funktion som skickar ett meddelande till den förkonfigurerade lösningen:

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

Lägg till följande motringningshanterare som körs när enheten har skickat nya rapporterade egenskapsvärden till den förkonfigurerade lösningen:

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

Lägg till följande funktion för att ansluta enheten till den förkonfigurerade lösningen i molnet och utbyta data. Den här funktionen utför följande steg:

Initierar plattformen.
Registrerar Contoso-namnområdet med serialiseringsbiblioteket.
Initierar klienten med enhetsanslutningssträngen.
Skapa en instans av termostatmodellen .
Skapar och skickar rapporterade egenskapsvärden.
Skickar ett DeviceInfo-objekt .
Skapar en loop för att skicka telemetri varje sekund.
Deinitialiserar alla resurser.

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

Här är ett exempel på ett telemetrimeddelande som skickas till den förkonfigurerade lösningen:

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

Anropa remote_monitoring_run funktionen

Öppna filen remote_monitoring.h i en textredigerare. Lägg till följande kod:

void remote_monitoring_run(void);

Öppna filen main.c i en textredigerare. Lägg till följande kod:

#include "remote_monitoring.h"

int main(void)
{
    remote_monitoring_run();

    return 0;
}

Skapa och köra programmet

Följande steg beskriver hur du använder CMake för att skapa klientprogrammet.

Öppna filenCMakeLists.txt i mappen remote_monitoring i en textredigerare.

Lägg till följande instruktioner för att definiera hur du skapar klientprogrammet:

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
)

I mappen remote_monitoring skapar du en mapp för att lagra filerna som CMake genererar och kör sedan cmake och gör kommandon på följande sätt:
```
mkdir cmake
cd cmake
cmake ../
make
```
Kör klientprogrammet och skicka telemetri till IoT Hub:
```
./sample_app
```

Visa enhetstelemetri på instrumentpanelen

Med instrumentpanelen i fjärrövervakningslösningen kan du visa telemetrin som dina enheter skickar till IoT Hub.

Gå tillbaka till instrumentpanelen för fjärrövervakningslösningen i webbläsaren och klicka på Enheter i den vänstra panelen för att gå till listan Enheter.
I enhetslistan bör du se att statusen för din enhet är Körs. Annars klickar du på Aktivera enhet på panelen Enhetsinformation .
Klicka på Instrumentpanel för att återgå till instrumentpanelen, välj enheten i listrutan Enhet för att visa dess telemetri. Telemetrin från exempelprogrammet är 50 enheter för intern temperatur, 55 enheter för extern temperatur och 50 enheter för luftfuktighet.

Anropa en metod på enheten

Med instrumentpanelen i fjärrövervakningslösningen kan du anropa metoder på dina enheter via IoT Hub. I fjärrövervakningslösningen kan du till exempel anropa en metod för att simulera omstart av en enhet.

I instrumentpanelen för fjärrövervakningslösningen klickar du på Enheter i den vänstra panelen för att gå till listan Enheter.
Klicka på Enhets-ID för din enhet i listan Enheter.
I panelen Enhetsinformation klickar du på Metoder.
I listrutan Metod väljer du InitiateFirmwareUpdate och anger sedan en dummy-URL i FWPACKAGEURI . Klicka på Anropa metod för att anropa metoden på enheten.
Du ser ett meddelande i konsolen som kör enhetskoden när enheten hanterar metoden. Resultatet av metoden läggs till i historiken i lösningsportalen:

Nästa steg

I artikeln Anpassa förkonfigurerade lösningar beskrivs några sätt att utöka det här exemplet. Möjliga tillägg omfattar användning av verkliga sensorer och implementering av ytterligare kommandon.

Du kan lära dig mer om behörigheterna på azureiotsuite.com-webbplatsen.

Last updated on 2017-11-02

Dela via