Verbinden Ihres Geräts mit der vorkonfigurierten Remoteüberwachungslösung (Windows)

Artikel
11/02/2017

Beschreibung des Szenarios

In diesem Szenario erstellen Sie ein Gerät, das die folgende Telemetrie an die vorkonfigurierte Fernüberwachungslösung sendet:

Außentemperatur
Interne Temperatur
Feuchtigkeit

Aus Gründen der Einfachheit generiert der Code auf dem Gerät Beispielwerte, aber wir empfehlen Ihnen, das Beispiel zu erweitern, indem sie echte Sensoren mit Ihrem Gerät verbinden und echte Telemetrie senden.

Das Gerät kann auch auf Methoden reagieren, die aus dem Lösungsdashboard aufgerufen werden, und die gewünschten Eigenschaftswerte, die im Lösungsdashboard festgelegt wurden.

Um dieses Lernprogramm abzuschließen, benötigen Sie ein aktives Azure-Konto. Wenn Sie über kein Konto verfügen, können Sie in nur wenigen Minuten ein kostenloses Testkonto erstellen. Ausführliche Informationen finden Sie unter Einen Monat kostenlos testen.

Bevor du anfängst

Bevor Sie Code für Ihr Gerät schreiben, müssen Sie Ihre vorkonfigurierte Remoteüberwachungslösung bereitstellen und ein neues benutzerdefiniertes Gerät in dieser Lösung bereitstellen.

Bereitstellen Sie Ihre vorkonfigurierte Remoteüberwachungslösung

Das in diesem Lernprogramm erstellte Gerät sendet Daten an eine Instanz der vorkonfigurierten Remoteüberwachungslösung . Wenn Sie die vorkonfigurierte Lösung für die Remoteüberwachung noch nicht in Ihrem Azure-Konto bereitgestellt haben, führen Sie die folgenden Schritte aus:

Klicken Sie auf der Seite https://www.azureiotsolutions.com/ auf +, um eine Lösung zu erstellen.
Klicken Sie auf und wählen Sie auf dem Bedienfeld für die Remoteüberwachung aus, um Ihre Lösung zu erstellen.
Geben Sie auf der Seite Seite "Remoteüberwachungslösung erstellen" einen Lösungsnamen Ihrer Wahl ein, wählen Sie die Region aus, in der Sie bereitstellen möchten, und wählen Sie das Azure-Abonnement aus, das Sie verwenden möchten. Klicken Sie dann auf Lösungerstellen.
Warten Sie, bis der Bereitstellungsprozess abgeschlossen ist.

Warnung

Die vorkonfigurierten Lösungen verwenden abrechnungsfähige Azure-Dienste. Entfernen Sie die vorkonfigurierte Lösung unbedingt aus Ihrem Abonnement, wenn Sie damit fertig sind, um unnötige Gebühren zu vermeiden. Sie können eine vorkonfigurierte Lösung vollständig aus Ihrem Abonnement entfernen, indem Sie die seite https://www.azureiotsolutions.com/ besuchen.

Wenn der Bereitstellungsprozess für die Remoteüberwachungslösung abgeschlossen ist, klicken Sie auf Starten, um das Lösungsdashboard in Ihrem Browser zu öffnen.

Lösungsdashboard

Bereitstellen Ihres Geräts in der Remoteüberwachungslösung

Hinweis

Wenn Sie bereits ein Gerät in Ihrer Lösung bereitgestellt haben, können Sie diesen Schritt überspringen. Sie müssen die Geräteanmeldeinformationen kennen, wenn Sie die Clientanwendung erstellen.

Damit ein Gerät eine Verbindung mit der vorkonfigurierten Lösung herstellen kann, muss es sich mit gültigen Anmeldeinformationen für IoT Hub identifizieren. Sie können die Geräteanmeldeinformationen aus dem Lösungsdashboard abrufen. Sie fügen die Geräteanmeldeinformationen später in diesem Tutorial in Ihre Clientanwendung ein.

Führen Sie die folgenden Schritte im Lösungsdashboard aus, um Ihrer Remoteüberwachungslösung ein Gerät hinzuzufügen:

Klicken Sie in der unteren linken Ecke des Dashboards auf Gerät hinzufügen.
Klicken Sie im Bereich Benutzerdefiniertes Gerät auf Neuenhinzufügen.
Wählen Sie Lassen Sie mich meine eigene Geräte-IDdefinieren. Geben Sie eine Geräte-ID wie mydeviceein, klicken Sie auf ID überprüfen, um zu überprüfen, ob der Name noch nicht verwendet wird, und klicken Sie dann auf Erstellen, um das Gerät bereitzustellen.
Notieren Sie sich die Geräteanmeldeinformationen (Geräte-ID, IoT Hub-Hostname und Device Key). Ihre Clientanwendung benötigt diese Werte, um eine Verbindung mit der Remoteüberwachungslösung herzustellen. Klicken Sie anschließend auf Fertig.
Wählen Sie Ihr Gerät in der Geräteliste im Lösungsdashboard aus. Klicken Sie dann im Bereich Gerätedetails auf Gerätaktivieren. Der Status Ihres Geräts ist jetzt Running. Die Remoteüberwachungslösung kann jetzt Telemetrie von Ihrem Gerät empfangen und Methoden auf dem Gerät aufrufen.

Erstellen einer C-Beispiellösung unter Windows

Die folgenden Schritte zeigen, wie Sie eine Clientanwendung erstellen, die mit der vorkonfigurierten Lösung für die Remoteüberwachung kommuniziert. Diese Anwendung wird in C geschrieben und unter Windows erstellt und ausgeführt.

Erstellen Sie ein Startprojekt in Visual Studio 2015 oder Visual Studio 2017, und fügen Sie die NuGet-Pakete des IoT Hub-Geräteclients hinzu:

Erstellen Sie in Visual Studio eine C-Konsolenanwendung mit der Visual C++-Win32-Konsolenanwendung Vorlage. Benennen Sie das Projekt RMDevice.
Stellen Sie auf der Seite Anwendungseinstellungen im Win32-Anwendungs-Assistentensicher, dass Konsolenanwendung ausgewählt ist, und deaktivieren Sie die Option Vorkompilierter Header und Security Development Lifecycle (SDL)-Prüfungen.
Löschen Sie im Projektmappen-Explorerdie Dateien stdafx.h, targetver.h und stdafx.cpp.
Benennen Sie im Projektmappen-Explorerdie Datei RMDevice.cpp in RMDevice.c um.
Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das RMDevice Projekt, und klicken Sie dann auf NuGet-Paketeverwalten. Klicken Sie auf Durchsuchen, und suchen Sie dann nach den folgenden NuGet-Paketen, und installieren Sie sie:
- Microsoft.Azure.IoTHub.Serializer
- Microsoft.Azure.IoTHub.IoTHubClient
- Microsoft.Azure.IoTHub.MqttTransport
Klicken Sie im Solution Explorermit der rechten Maustaste auf das RMDevice-Projekt und dann auf Eigenschaften, um das Dialogfeld Eigenschaftenseiten des Projekts zu öffnen. Weitere Informationen hierzu finden Sie unter Festlegen von Visual C++-Projekteigenschaften.
Klicken Sie auf den Ordner Linker, und klicken Sie dann auf die Eingabe-Eigenschaftenseite .
Fügen Sie crypt32.lib zur eigenschaft Additional Dependencies hinzu. Klicken Sie auf OK und dann erneut auf OK, um die Projekteigenschaftswerte zu speichern.

Fügen Sie die Parson JSON-Bibliothek zum RMDevice Projekt hinzu, und fügen Sie die erforderlichen #include Anweisungen hinzu:

Klonen Sie in einem geeigneten Ordner auf Ihrem Computer das Parson GitHub-Repository mit dem folgenden Befehl:
```
git clone https://github.com/kgabis/parson.git
```
Kopieren Sie die Dateien parson.h und parson.c aus der lokalen Kopie des Parson-Repositorys in Ihren RMDevice Projektordner.
Klicken Sie in Visual Studio mit der rechten Maustaste auf das RMDevice-Projekt, klicken Sie auf Hinzufügen, und klicken Sie dann auf Vorhandenes Element.
Im -Dialogfeld "Vorhandenes Element hinzufügen" wählen Sie die Dateien "parson.h" und "parson.c" im Projektordner "RMDevice" aus. Klicken Sie dann auf Hinzufügen, um diese beiden Dateien zu Ihrem Projekt hinzuzufügen.

Öffnen Sie in Visual Studio die Datei RMDevice.c. Ersetzen Sie die vorhandenen #include-Anweisungen durch den folgenden Code:

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

Hinweis

Jetzt können Sie überprüfen, ob Ihr Projekt die richtigen Abhängigkeiten eingerichtet hat, indem Sie es erstellen.

Angeben des Verhaltens des IoT-Geräts

Die IoT Hub Serializer-Clientbibliothek verwendet ein Modell, um das Format der Nachrichten anzugeben, die das Gerät mit IoT Hub austauscht.

Fügen Sie die folgenden Variablendeklarationen nach den #include-Anweisungen hinzu. Ersetzen Sie die Platzhalterwerte [Geräte-ID] und [Geräteschlüssel] durch Werte, die Sie für Ihr Gerät im Remoteüberwachungslösungsdashboard angegeben haben. Verwenden Sie den IoT Hub-Hostname aus dem Lösungsdashboard, um [IoTHub-Name] zu ersetzen. Wenn Ihr IoT Hub-Hostname beispielsweise contoso.azure-devices.netist, ersetzen Sie [IoTHub Name] durch contoso:
```
static const char* deviceId = "[Device Id]";
static const char* connectionString = "HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]";
```

Fügen Sie den folgenden Code hinzu, um das Modell zu definieren, mit dem das Gerät mit IoT Hub kommunizieren kann. Dieses Modell gibt an, dass das Gerät:

Kann Temperatur, externe Temperatur, Feuchtigkeit und eine Geräte-ID als Telemetrie senden.
Kann Metadaten über das Gerät an IoT Hub senden. Das Gerät sendet grundlegende Metadaten in einem DeviceInfo--Objekt beim Start.
Kann gemeldete Eigenschaften an das Gerät Twin im IoT Hub senden. Diese gemeldeten Eigenschaften werden in Konfigurations-, Geräte- und Systemeigenschaften gruppiert.
Kann gewünschte Eigenschaften empfangen und darauf reagieren, die im Geräte-Twin im IoT Hub festgelegt sind.
Kann auf die über das Lösungsportal aufgerufenen direkten Methoden Reboot und InitiateFirmwareUpdate reagieren. Das Gerät sendet Informationen zu den direkten Methoden, die es unterstützt, mithilfe von gemeldeten Eigenschaften.

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

Das Verhalten des Geräts implementieren

Fügen Sie nun Code hinzu, der das im Modell definierte Verhalten implementiert.

Fügen Sie die folgenden Funktionen hinzu, die die gewünschten Eigenschaften behandeln, die im Lösungsdashboard festgelegt sind. Diese gewünschten Eigenschaften werden im Modell definiert:

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

Fügen Sie die folgenden Funktionen hinzu, die die direkten Methoden behandeln, die über den IoT-Hub aufgerufen werden. Diese direkten Methoden werden im Modell definiert:

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

Fügen Sie die folgende Funktion hinzu, die eine Nachricht an die vorkonfigurierte Lösung sendet:

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

Fügen Sie den folgenden Rückrufhandler hinzu, der ausgeführt wird, wenn das Gerät neue gemeldete Eigenschaftswerte an die vorkonfigurierte Lösung gesendet hat:

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

Fügen Sie die folgende Funktion hinzu, um Ihr Gerät mit der vorkonfigurierten Lösung in der Cloud zu verbinden und Daten auszutauschen. Diese Funktion führt die folgenden Schritte aus:

Initialisiert die Plattform.
Registriert den Contoso-Namespace mit der Serialisierungsbibliothek.
Initialisiert den Client mit der Geräteverbindungszeichenfolge.
Erstellen Sie eine Instanz des Thermometer- Modells.
Erstellt und sendet gemeldete Eigenschaftswerte.
Sendet ein -DeviceInfo--Objekt.
Erstellt eine Schleife, um Telemetrie jede Sekunde zu senden.
Deinitialisiert alle Ressourcen.

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

Zur Orientierung, hier ist ein Beispiel für eine Telemetrie Nachricht, das an die vorkonfigurierte Lösung gesendet wurde.

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

Erstellen und Ausführen des Beispiels

Fügen Sie Code hinzu, um die remote_monitoring_run-Funktion aufzurufen, und erstellen Sie dann die Geräteanwendung, und führen Sie sie aus.

Ersetzen Sie die Hauptfunktion durch folgenden Code, um die remote_monitoring_run-Funktion aufzurufen:
```
int main()
{
  remote_monitoring_run();
  return 0;
}
```
Klicken Sie auf Erstellen und dann auf Lösung erstellen, um die Geräteanwendung zu erstellen.
Klicken Sie im Projektmappen-Explorermit der rechten Maustaste auf das RMDevice Projekt, klicken Sie auf Debug, und klicken Sie dann auf Neue Instanz starten, um das Beispiel auszuführen. Die Konsole zeigt Meldungen an, wenn die Anwendung Beispiel-Telemetrie an die vorkonfigurierte Lösung sendet, im Lösungsdashboard festgelegte Eigenschaftswerte empfängt und auf Methoden reagiert, die aus dem Lösungsdashboard aufgerufen werden.

Anzeigen der Gerätetelemetrie im Dashboard

Mit dem Dashboard in der Remoteüberwachungslösung können Sie die Telemetrie anzeigen, die Ihre Geräte an IoT Hub senden.

Kehren Sie in Ihrem Browser zum Dashboard der Remoteüberwachungslösung zurück und klicken Sie im linken Panel auf Geräte, um zur Liste Gerätezu gelangen.
In der Liste Gerätesollten Sie sehen, dass der Status Ihres Geräts Ausführenist. Falls nicht, klicken Sie im Bereich Gerätedetails auf Device aktivieren.
Klicken Sie auf Dashboard, um zum Dashboard zurückzukehren. Wählen Sie Ihr Gerät im Dropdown-Menü 'Gerät zum Anzeigen' aus, um seine Telemetrie anzuzeigen. Die Telemetrie aus der Stichprobenanwendung beträgt 50 Einheiten für interne Temperatur, 55 Einheiten für externe Temperatur und 50 Einheiten für Feuchtigkeit.

Aufrufen einer Methode auf Ihrem Gerät

Mit dem Dashboard in der Remoteüberwachungslösung können Sie Methoden auf Ihren Geräten über IoT Hub aufrufen. In der Remoteüberwachungslösung können Sie beispielsweise eine Methode aufrufen, um den Neustart eines Geräts zu simulieren.

Klicken Sie im Dashboard der Lösung für Remoteüberwachung im linken Bereich auf Geräte, um zur Liste der Gerätezu navigieren.
Klicken Sie auf die Geräte-ID Ihres Geräts in der Liste Geräte.
Klicken Sie im Bereich Gerätedetails auf Methoden.
Wählen Sie in der Dropdownliste MethodeInitiateFirmwareUpdateaus, und geben Sie dann bei FWPACKAGEURI eine Dummy-URL ein. Klicken Sie auf , um die Methode auf dem Gerät aufzurufen.
Sie sehen eine Meldung in der Konsole, die Ihren Gerätecode ausführt, wenn das Gerät die Methode verarbeitet. Die Ergebnisse der Methode werden dem Verlauf im Lösungsportal hinzugefügt:

Nächste Schritte

Im Artikel Anpassen von vorkonfigurierten Lösungen werden einige Möglichkeiten beschrieben, wie Sie dieses Beispiel erweitern können. Mögliche Erweiterungen umfassen die Verwendung realer Sensoren und die Implementierung zusätzlicher Befehle.

Weitere Informationen zu den Berechtigungen finden Sie auf der azureiotsuite.com-Website.

Freigeben über