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

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 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. Gå 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.

I filen remote_monitoring.js lägger du till följande require-instruktioner:

'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 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:
```
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 direktmetodsanropet Starta om:

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