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

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

Bereitstellung Ihres Geräts in der Lösung für Fernüberwachung

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.

Eine node.js-Beispiellösung erstellen

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

Erstellen Sie einen Ordner namens RemoteMonitoring- auf Ihrem Entwicklungscomputer. Navigieren Sie in Ihrer Befehlszeilenumgebung zu diesem Ordner.
Führen Sie die folgenden Befehle aus, um die Pakete herunterzuladen und zu installieren, die Sie zum Abschließen 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 Text-Editor.

Fügen Sie in 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 [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:
```
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 Basis-Telemetriedaten zu definieren:
```
var temperature = 50;
var humidity = 50;
var externalTemperature = 55;
```

Fügen Sie die folgende Hilfsfunktion zum Drucken von Vorgangsergebnissen hinzu:

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

Fügen Sie die folgende Hilfsfunktion hinzu, um die Telemetriewerte zu zufälligisieren:
```
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 geräte twin gemeldeten Werte hinzu. Diese Definition enthält 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 hinzu, um die Behandlung des direkten Methodenaufrufs für den Reboot zu übernehmen.

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 hinzu, um den direkten Methodenaufruf InitiateFirmwareUpdate zu behandeln. Diese direkte Methode verwendet einen Parameter, um den Speicherort des herunterzuladenden Firmwareimages anzugeben und initiiert das Firmwareupdate auf dem Gerät asynchron:

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 hinzu, um eine Clientinstanz zu erstellen:
```
var client = Client.fromConnectionString(connectionString, Protocol);
```

Fügen Sie den folgenden Code hinzu:

Öffnen Sie die Verbindung.
Senden Sie das DeviceInfo--Objekt.
Richten Sie einen Handler für die gewünschten Eigenschaften ein.
Gemeldete Eigenschaften senden.
Registrieren Sie Handler für die direkten Methoden.
Beginnen Sie mit dem Senden von Telemetrie.

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 remote_monitoring.js Datei.
Führen Sie an einer Eingabeaufforderung den folgenden Befehl aus, um die Beispielanwendung zu starten:
```
node remote_monitoring.js
```

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