Ansluta enheten till den förkonfigurerade fjärrövervakningslösningen (Node.js)

Artikel
11/02/2017

Översikt över scenario

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

Extern temperatur
Intern temperatur
Luftfuktighet

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

Enheten kan även svara på metoderna som anropas från lösningens instrumentpanel och de önskade egenskapsvärden som är angivna i lösningens instrumentpanel.

Du behöver ett Azure-konto för att slutföra den här självstudiekursen. Om du inte har något konto kan skapa du ett kostnadsfritt utvärderingskonto på bara några minuter. Mer information om den kostnadsfria utvärderingsversionen av Azure finns Kostnadsfri utvärderingsversion av Azure.

Innan du börjar

Innan du kan skriva kod för enheten måste du etablera din förkonfigurerade lösning för fjärrövervakning och etablera en ny anpassad enhet i lösningen.

Etablera din förkonfigurerade lösning för fjärrövervakning

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

På sidan https://www.azureiotsolutions.com/ klickar du 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 Create Remote monitoring solution (Skapa fjärrövervakningslösning) anger du ett Lösningsnamn och väljer den Region du vill distribuera till samt väljer den Azure-prenumerationen som du vill använda. Klicka på Skapa lösning.
Vänta tills etableringsprocessen har slutförts.

Varning

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

När etableringen av fjärrövervakningslösningen är klar klickar du på Starta för att öppna lösningens instrumentpanel i webbläsaren.

Instrumentpanel för lösningen

Etablera enheten i fjärrövervakningslösningen

Anteckning

Om du redan har etablerat en enhet i din lösning kan du hoppa över det här steget. Du behöver 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 kan inkludera enhetsautentiseringsuppgifterna i klientprogrammet senare i den här självstudien.

Om du vill lägga till en enhet till din fjärrövervakningslösning utför du följande steg i lösningens instrumentpanel:

Klicka på Lägg till en enhet i det nedre vänstra hörnet på instrumentpanelen.
I panelen Anpassad enhet klickar du på Lägg till ny.
Välj Låt mig ange mitt eget enhets-ID. Ange ett enhets-ID, t.ex. mydevice och klicka på Kontrollera ID för att kontrollera att namnet inte redan används. Klicka sedan på Skapa för att etablera enheten.
Notera enhetsautentiseringsuppgifterna (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å Klar.
Välj enheten i enhetslistan i lösningens instrumentpanel. Klicka sedan på Aktivera enhet i panelen Enhetsinformation. Statusen för din enhet är nu Körs. Fjärrövervakningslösningen kan nu ta emot telemetri från enheten och anropa metoder på enheten.

Skapa en node.js exempellösning

Kontrollera att Node.js version 0.11.5 eller senare är installerad på utvecklingsdatorn. Du kan köra node --version på kommandoraden för att kontrollera versionen.

Skapa en mapp med namnet RemoteMonitoring på utvecklingsdatorn. Navigera till den här mappen i kommandoradsmiljön.
Kör följande kommandon för att ladda ned och installera de paket som du behöver för att slutföra exempelappen:
```
npm init
npm install azure-iot-device azure-iot-device-mqtt --save
```
I mappen RemoteMonitoring skapar du en fil med namnet remote_monitoring.js. Öppna den här filen i en textredigerare.

Lägg till följande require instruktioner i filenremote_monitoring.js:

'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;

Lägg till följande variabeldeklarationer efter require-instruktionerna. Ersätt platshållarvärdena [Enhets-ID] och [Enhetsnyckel] med de värden du antecknade för enheten i instrumentpanelen för fjärrövervakningslösningen. Använd värdnamnet för IoT Hub från lösningens instrumentpanel för att ersätta [IoTHub-namn]. Om ditt värdnamn för IoT Hub exempelvis är contoso.azure-devices.net ersätter du [IoTHub-namn] med contoso:
```
var connectionString = 'HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]';
var deviceId = ConnectionString.parse(connectionString).DeviceId;
```
Lägg till följande variabler för att definiera vissa bastelemetridata:
```
var temperature = 50;
var humidity = 50;
var externalTemperature = 55;
```

Lägg till följande hjälpfunktion för att skriva ut åtgärdsresultat:

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

Lägg till följande hjälpfunktion som ska användas för att randomisera telemetrivärdena:
```
function generateRandomIncrement() {
    return ((Math.random() * 2) - 1);
}
```

Lägg till följande definition för DeviceInfo-objektet som enheten skickar vid start:

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

Lägg till följande definition för enhetstvillingens rapporterade värden. Den här definitionen innehåller beskrivningar av de direkta metoder som enheten stöder:

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"
    },
}

Lägg till följande funktion för att hantera anropet Starta om direktmetod:

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

Lägg till följande funktion för att hantera direct method-anropet InitiateFirmwareUpdate . Den här direktmetoden använder en parameter för att ange platsen för avbildningen av den inbyggda programvaran som ska laddas ned och initierar uppdateringen av den inbyggda programvaran på enheten asynkront:

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
}

Lägg till följande kod för att skapa en klientinstans:

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

Lägg till följande kod i:

Öppna anslutningen.
Skicka DeviceInfo-objektet .
Konfigurera en hanterare för önskade egenskaper.
Skicka rapporterade egenskaper.
Registrera hanterare för direktmetoderna.
Börja skicka telemetri.

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

Spara ändringarna i remote_monitoring.js-filen .
Kör följande kommando i en kommandotolk för att starta exempelprogrammet:
```
node remote_monitoring.js
```

Visa enhetstelemetri i instrumentpanelen

Instrumentpanelen i fjärrövervakningslösningen visar den telemetri som enheterna skickar till IoT Hub.

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

Anropa en metod på enheten

Instrumentpanelen i fjärrövervakningslösningen låter dig anropa metoder på enheterna genom IoT Hub. Du kan till exempel anropa en metod för att simulera en omstart av en enhet i fjärrövervakningslösningen.

I fjärrövervakningslösningens instrumentpanel klickar du på Enheter i den vänstra panelen för att navigera till Enhetslistan.
Klicka på din enhets Enhets-ID i enhetslistan.
I panelen Enhetsinformation klickar du på Metoder.
I listrutan Metodväljer du InitiateFirmwareUpdate och sedan anger du 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. Resultaten av metoden läggs till i historiken i lösningsportalen:

Nästa steg

Artikeln Anpassning av förkonfigurerade lösningar beskriver några sätt du kan utöka det här exemplet. Möjliga tillägg kan vara att använda riktiga sensorer och att implementera ytterligare kommandon.

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

Dela via