Verbinden Ihres Geräts mit der vorkonfigurierten Remoteüberwachungslösung (Node.js)

Artikel
11/02/2017

Übersicht über das Szenario

In diesem Szenario erstellen Sie ein Gerät, das die folgenden Telemetriedaten an die vorkonfigurierte Lösung für die Remoteüberwachung sendet:

Externe Temperatur
Interne Temperatur
Luftfeuchtigkeit

Zur Vereinfachung erzeugt der Code auf dem Gerät Beispielwerte. Sie sollten das Beispiel jedoch erweitern, indem Sie echte Sensoren an Ihr Gerät anschließen und tatsächliche Telemetriedaten senden.

Das Gerät kann auch auf Methoden antworten, die über das Lösungsdashboard aufgerufen werden, und auf die gewünschten Eigenschaftswerte, die im Lösungsdashboard festgelegt werden.

Um dieses Tutorial 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.

Vorbereitung

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

Bereitstellen der vorkonfigurierten Lösung für die Remoteüberwachung

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

Klicken Sie auf der Seite https://www.azureiotsolutions.com/ auf +, um eine Lösung zu erstellen.
Klicken Sie im Bereich Remoteüberwachung auf Auswählen, um die Lösung zu erstellen.
Geben Sie auf der Seite Create Remote monitoring solution (Remoteüberwachungslösung erstellen) einen Lösungsnamen Ihrer Wahl ein, wählen Sie die gewünschte Region für die Bereitstellung aus, und wählen Sie dann das gewünschte Azure-Abonnement aus. Klicken Sie dann auf Lösung erstellen.
Warten Sie, bis der Bereitstellungsvorgang abgeschlossen ist.

Warnung

Die vorkonfigurierten Lösungen verwenden abrechenbare Azure-Dienste. Achten Sie darauf, die vorkonfigurierte Lösung aus dem Abonnement zu entfernen, wenn Sie 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 im Browser zu öffnen.

Lösungsdashboard

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

Hinweis

Wenn Sie bereits ein Gerät in der Lösung bereits bereitgestellt haben, können Sie diesen Schritt überspringen. Für das Erstellen der Clientanwendung müssen Sie die Anmeldeinformationen des Geräts kennen.

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

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

Klicken Sie in der linken unteren Ecke des Dashboards auf Gerät hinzufügen.
Klicken Sie im Bereich Benutzerdefiniertes Gerät auf Neue hinzufügen.
Wählen Sie die Option Ich möchte meine eigene Geräte-ID definieren. Geben Sie eine Geräte-ID wie mydevice ein, und klicken Sie auf ID prüfen, um zu prüfen, ob der Name bereits verwendet wird. Klicken Sie dann auf Erstellen, um das Gerät bereitzustellen.
Notieren Sie sich die Anmeldeinformationen des Geräts (Geräte-ID, IoT Hub-Hostname und Geräteschlüssel). 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 im Lösungsdashboard in der Liste mit den Geräten aus. Klicken Sie anschließend im Bereich Gerätedetails auf Gerät aktivieren. Der Status Ihres Geräts lautet jetzt Wird ausgeführt. Die Remoteüberwachungslösung kann jetzt Telemetriedaten von Ihrem Gerät empfangen und Methoden auf dem Gerät aufrufen.

Erstellen einer Node.js-Beispiellösung

Stellen Sie sicher, dass auf dem Entwicklungscomputer mindestens die Node.js-Version 0.11.5 oder höher installiert ist. Sie können node --version in der Befehlszeile ausführen, um die Version zu überprüfen.

Erstellen Sie auf Ihrem Entwicklungscomputer einen Ordner namens RemoteMonitoring. Navigieren Sie in der Befehlszeilenumgebung zu diesem Ordner.
Führen Sie die folgenden Befehle zum Herunterladen und Installieren der Pakete aus, die Sie zum Fertigstellen der Beispiel-App benötigen:
```
npm init
npm install azure-iot-device azure-iot-device-mqtt --save
```
Erstellen Sie im Ordner RemoteMonitoring eine Datei namens remote_monitoring.js. Öffnen Sie diese Datei in einem Texteditor.

Fügen Sie der Datei remote_monitoring.js die folgenden require-Anweisungen hinzu:

'use strict';

var Protocol = require('azure-iot-device-mqtt').Mqtt;
var Client = require('azure-iot-device').Client;
var ConnectionString = require('azure-iot-device').ConnectionString;
var Message = require('azure-iot-device').Message;

Fügen Sie die folgenden Variablendeklarationen nach den require -Anweisungen hinzu. Ersetzen Sie die Platzhalterwerte „[Device Id]“ und „[Device Key]“ durch die Werte, die Sie für Ihr Gerät aus dem Dashboard der Remoteüberwachungslösung notiert haben. Ersetzen Sie „[IoTHub Name]“ durch den IoT Hub-Hostnamen aus dem Lösungsdashboard. Beispiel: Wenn der IoT Hub-Hostname contoso.azure-devices.net lautet, ersetzen Sie [IoTHub Name] durch contoso:
```
var connectionString = 'HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]';
var deviceId = ConnectionString.parse(connectionString).DeviceId;
```
Fügen Sie die folgenden Variablen hinzu, um einige grundlegende Telemetriedaten zu definieren:
```
var temperature = 50;
var humidity = 50;
var externalTemperature = 55;
```

Fügen Sie die folgende Hilfsfunktion hinzu, um Ergebnisse des Vorgangs auszugeben:

function printErrorFor(op) {
    return function printError(err) {
        if (err) console.log(op + ' error: ' + err.toString());
    };
}

Fügen Sie die folgende Hilfsfunktion für die zufällige Festlegung der Telemetriewerte hinzu:
```
function generateRandomIncrement() {
    return ((Math.random() * 2) - 1);
}
```

Fügen Sie die folgende Definition für das DeviceInfo-Objekt hinzu, das das Gerät beim Start sendet:

var deviceMetaData = {
    'ObjectType': 'DeviceInfo',
    'IsSimulatedDevice': 0,
    'Version': '1.0',
    'DeviceProperties': {
        'DeviceID': deviceId,
        'HubEnabledState': 1
    }
};

Fügen Sie die folgende Definition für die vom Gerätezwilling gemeldeten Werte hinzu. Diese Definition umfasst Beschreibungen der direkten Methoden, die das Gerät unterstützt:

var reportedProperties = {
    "Device": {
        "DeviceState": "normal",
        "Location": {
            "Latitude": 47.642877,
            "Longitude": -122.125497
        }
    },
    "Config": {
        "TemperatureMeanValue": 56.7,
        "TelemetryInterval": 45
    },
    "System": {
        "Manufacturer": "Contoso Inc.",
        "FirmwareVersion": "2.22",
        "InstalledRAM": "8 MB",
        "ModelNumber": "DB-14",
        "Platform": "Plat 9.75",
        "Processor": "i3-9",
        "SerialNumber": "SER99"
    },
    "Location": {
        "Latitude": 47.642877,
        "Longitude": -122.125497
    },
    "SupportedMethods": {
        "Reboot": "Reboot the device",
        "InitiateFirmwareUpdate--FwPackageURI-string": "Updates device Firmware. Use parameter FwPackageURI to specifiy the URI of the firmware file"
    },
}

Fügen Sie die folgende Funktion zur Behandlung des Aufrufs der direkten Methode Reboot hinzu:

function onReboot(request, response) {
    // Implement actual logic here.
    console.log('Simulated reboot...');

    // Complete the response
    response.send(200, "Rebooting device", function(err) {
        if(!!err) {
            console.error('An error occurred when sending a method response:\n' + err.toString());
        } else {
            console.log('Response to method \'' + request.methodName + '\' sent successfully.' );
        }
    });
}

Fügen Sie die folgende Funktion zur Behandlung des Aufrufs der direkten Methode InitiateFirmwareUpdate hinzu. Diese direkte Methode verwendet einen Parameter zum Angeben des Speicherorts des Firmware-Images, das heruntergeladen werden soll, und leitet das Firmwareupdate auf dem Gerät asynchron ein:

function onInitiateFirmwareUpdate(request, response) {
    console.log('Simulated firmware update initiated, using: ' + request.payload.FwPackageURI);

    // Complete the response
    response.send(200, "Firmware update initiated", function(err) {
        if(!!err) {
            console.error('An error occurred when sending a method response:\n' + err.toString());
        } else {
            console.log('Response to method \'' + request.methodName + '\' sent successfully.' );
        }
    });

    // Add logic here to perform the firmware update asynchronously
}

Fügen Sie den folgenden Code zum Erstellen einer Clientinstanz hinzu:

var client = Client.fromConnectionString(connectionString, Protocol);

Fügen Sie den folgenden Code zu folgenden Zwecken hinzu:

Öffnen Sie die Verbindung.
Senden des DeviceInfo-Objekts.
Einrichten eines Handlers für die gewünschten Eigenschaften.
Senden gemeldeter Eigenschaften.
Registrieren des Handlers für die direkten Methoden.
Starten des Sendens von Telemetriedaten.

client.open(function (err) {
    if (err) {
        printErrorFor('open')(err);
    } else {
        console.log('Sending device metadata:\n' + JSON.stringify(deviceMetaData));
        client.sendEvent(new Message(JSON.stringify(deviceMetaData)), printErrorFor('send metadata'));

        // Create device twin
        client.getTwin(function(err, twin) {
            if (err) {
                console.error('Could not get device twin');
            } else {
                console.log('Device twin created');

                twin.on('properties.desired', function(delta) {
                    console.log('Received new desired properties:');
                    console.log(JSON.stringify(delta));
                });

                // Send reported properties
                twin.properties.reported.update(reportedProperties, function(err) {
                    if (err) throw err;
                    console.log('twin state reported');
                });

                // Register handlers for direct methods
                client.onDeviceMethod('Reboot', onReboot);
                client.onDeviceMethod('InitiateFirmwareUpdate', onInitiateFirmwareUpdate);
            }
        });

        // Start sending telemetry
        var sendInterval = setInterval(function () {
            temperature += generateRandomIncrement();
            externalTemperature += generateRandomIncrement();
            humidity += generateRandomIncrement();

            var data = JSON.stringify({
                'DeviceID': deviceId,
                'Temperature': temperature,
                'Humidity': humidity,
                'ExternalTemperature': externalTemperature
            });

            console.log('Sending device event data:\n' + data);
            client.sendEvent(new Message(data), printErrorFor('send event'));
        }, 5000);

        client.on('error', function (err) {
            printErrorFor('client')(err);
            if (sendInterval) clearInterval(sendInterval);
            client.close(printErrorFor('client.close'));
        });
    }
});

Speichern Sie die Änderungen in der Datei remote_monitoring.js.
Führen Sie den folgenden Befehl an einer Eingabeaufforderung aus, um die Beispielanwendung zu starten:
```
node remote_monitoring.js
```

Anzeigen der Gerätetelemetrie im Dashboard

Das Dashboard in der Remoteüberwachungslösung ermöglicht Ihnen das Anzeigen der Telemetrie, die Ihre Geräte an IoT Hub senden.

Wechseln Sie in Ihrem Browser zum Dashboard der Remoteüberwachungslösung, und klicken Sie im linken Bereich auf Geräte, um zur Geräteliste zu gelangen.
In der Geräteliste wird angezeigt, dass das Gerät den Status Wird ausgeführt hat. Wenn nicht, können Sie im Bereich Gerätedetails auf Gerät aktivieren.
Klicken Sie auf Dashboard, um zu diesem zurückzukehren. Wählen Sie in der Dropdownliste Anzuzeigendes Gerät Ihr Gerät aus, um dessen Telemetrie anzuzeigen. Die Telemetrie der Beispielanwendung ist mit 50 Einheiten für die Innentemperatur, 55 Einheiten für die Außentemperatur und 50 Einheiten für die Luftfeuchtigkeit konfiguriert.

Aufrufen einer Methode auf Ihrem Gerät

Das Dashboard in der Remoteüberwachungslösung ermöglicht es Ihnen, über IoT Hub Methoden auf Ihren Geräten aufzurufen. Beispielsweise können Sie in der Remoteüberwachungslösung eine Methode zum Simulieren des Neustarts eines Gerät aufrufen.

Klicken Sie im Dashboard der Remoteüberwachungslösung im linken Bereich auf Geräte, um zur Geräteliste zu gelangen.
Klicken Sie in der Geräteliste auf die Geräte-ID für Ihr Gerät.
Klicken Sie im Bereich Gerätedetails auf Methoden.
Wählen Sie in der Dropdownliste Methode die Option InitiateFirmwareUpdate, und geben Sie dann unter FWPACKAGEURI eine Pseudo-URL ein. Klicken Sie auf Invoke Method (Methode aufrufen), um die Methode auf dem Gerät aufzurufen.
In der Konsole wird bei der Ausführung Ihres Gerätecodes eine Meldung angezeigt, 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 vorkonfigurierter Lösungen werden einige Möglichkeiten zum Erweitern dieses Beispiels beschrieben. Mögliche Erweiterungen umfassen die Verwendung echter Sensoren und die Implementierung zusätzlicher Befehle.

Weitere Informationen finden Sie unter Berechtigungen für die Website „azureiotsuite.com“.

Freigeben über