Connettere il dispositivo alla soluzione preconfigurata per il monitoraggio remoto (Node.js)

Articolo
11/02/2017

Panoramica dello scenario

In questo scenario, viene creato un dispositivo che invia la seguente telemetria alla soluzione preconfigurata per il monitoraggio remoto:

Temperatura esterna
Temperatura interna
Umidità

Per semplicità, il codice nel dispositivo genera valori di esempio, ma si consiglia di estendere l'esempio connettendo i sensori reali al dispositivo e inviando i dati di telemetria reali.

Inoltre, il dispositivo è in grado di rispondere ai metodi richiamati dal dashboard di soluzione e ai valori di proprietà desiderati impostati nel dashboard di soluzione.

Per completare l'esercitazione, è necessario un account Azure attivo. Se non si dispone di un account Azure, è possibile creare un account di valutazione gratuito in pochi minuti. Per informazioni dettagliate, vedere la pagina relativa alla versione di valutazione gratuita di Azure.

Prima di iniziare

Prima di scrivere un codice per il dispositivo, occorre eseguire la soluzione preconfigurata di monitoraggio remoto e poi effettuare il provisioning di un nuovo dispositivo personalizzato all'interno della soluzione in questione.

Eseguire il provisioning della soluzione preconfigurata per il monitoraggio remoto

Il dispositivo creato in questa esercitazione invia dati a un'istanza della soluzione preconfigurata per il monitoraggio remoto. Se nel proprio account Azure non è già stato eseguito il provisioning della soluzione preconfigurata per il monitoraggio remoto, attenersi alla procedura seguente:

Nella pagina https://www.azureiotsolutions.com/, fare clic su + per creare una soluzione.
Fare clic su Seleziona nel pannello Remote monitoring (Monitoraggio remoto) per creare la soluzione.
Nella pagina per la creazione della soluzione di monitoraggio remoto immettere il nome desiderato in Nome soluzione e selezionare l'area in cui eseguire la distribuzione e quindi la sottoscrizione di Azure da usare. Fare clic su Crea soluzione.
Attendere finché non viene completato il processo di provisioning.

Avviso

Le soluzioni preconfigurate usano servizi di Azure fatturabili. Al termine, assicurarsi di rimuovere la soluzione preconfigurata dalla sottoscrizione per evitare eventuali addebiti non necessari. Per rimuovere completamente una soluzione preconfigurata dalla sottoscrizione, visitare la pagina https://www.azureiotsolutions.com/.

Al termine del processo di provisioning della soluzione di monitoraggio remoto, fare clic su Avvia per aprire il dashboard della soluzione nel browser.

Dashboard della soluzione

Effettuare il provisioning del dispositivo nella soluzione di monitoraggio remoto

Nota

Se è già stato eseguito il provisioning di un dispositivo nella soluzione, è possibile saltare questo passaggio. È necessario conoscere le credenziali del dispositivo quando si crea l'applicazione client.

Per connettere un dispositivo alla soluzione preconfigurata, è necessario che identifichi se stesso nell'hub IoT mediante delle credenziali valide. È possibile recuperare le credenziali del dispositivo dal dashboard della soluzione. Le istruzioni per includere le credenziali del dispositivo nell'applicazione client sono illustrate più avanti in questa esercitazione.

Per aggiungere un dispositivo alla soluzione di monitoraggio remoto, completare i passaggi seguenti nel dashboard della soluzione:

Nell'angolo inferiore sinistro del dashboard fare clic su Aggiungi un dispositivo.
Nel pannello Dispositivo personalizzato fare clic su Aggiungi nuovo.
Scegliere Let me define my own Device ID (Desidero definire il mio ID dispositivo). Immettere un ID dispositivo, ad esempio mydevice, fare clic su Controlla ID per verificare che tale nome non sia già in uso e quindi fare clic su Crea per effettuare il provisioning del dispositivo.
Annotare le credenziali del dispositivo (ID dispositivo, nome host dell'hub IoT e chiave dispositivo). Questi valori sono necessari per consentire all'applicazione client di connettersi alla soluzione di monitoraggio remoto. Fare quindi clic su Done.
Selezionare il dispositivo nell'elenco dei dispositivi nel dashboard della soluzione. Nel pannello Dettagli dispositivo fare clic su Attiva dispositivo. Lo stato del dispositivo è ora In esecuzione. La soluzione di monitoraggio remoto può ora ricevere i dati di telemetria dal dispositivo e richiamare i metodi sul dispositivo.

Creare una soluzione di esempio di Node.js

Verificare che nel computer di sviluppo sia installato Node.js 0.11.5 o versione successiva. Per controllare la versione è possibile eseguire node --version nella riga di comando.

Nel computer di sviluppo creare una cartella denominata RemoteMonitoring. Aprire la cartella nell'ambiente della riga di comando.
Eseguire i comandi seguenti per scaricare e installare i pacchetti necessari per completare l'applicazione di esempio:
```
npm init
npm install azure-iot-device azure-iot-device-mqtt --save
```
Nella cartella RemoteMonitoring, creare un file denominato remote_monitoring.js. Aprire il file in un editor di testo.

Nel file remote_monitoring.js, aggiungere le istruzioni require seguenti:

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

Aggiungere le seguenti dichiarazioni di variabili dopo le istruzioni require . Sostituire i valori segnaposto [ID dispositivo] e [Chiave dispositivo] con i valori annotati per il dispositivo nel dashboard della soluzione di monitoraggio remoto. Usare il nome host hub IoT del dashboard della soluzione per sostituire [Nome IoTHub]. Ad esempio, se il nome host dell'hub IoT è contoso.azure-devices.net, sostituire [Nome IoTHub] con contoso:
```
var connectionString = 'HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]';
var deviceId = ConnectionString.parse(connectionString).DeviceId;
```
Aggiungere le seguenti variabili per definire alcuni dati di telemetria di base:
```
var temperature = 50;
var humidity = 50;
var externalTemperature = 55;
```

Aggiungere la funzione helper seguente per stampare i risultati dell'operazione:

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

Aggiungere la funzione helper seguente per impostare in modo casuale i valori di telemetria:
```
function generateRandomIncrement() {
    return ((Math.random() * 2) - 1);
}
```

Aggiungere la definizione seguente per l'oggetto DeviceInfo inviato dal dispositivo all'avvio:

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

Aggiungere la definizione seguente per i valori segnalati del dispositivo gemello. La definizione include le descrizioni dei metodi diretti supportati dal dispositivo:

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

Aggiungere la funzione seguente per gestire la chiamata al metodo diretto Reboot:

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

Aggiungere la funzione seguente per gestire la chiamata al metodo diretto InitiateFirmwareUpdate. Questo metodo diretto usa un parametro per specificare il percorso dell'immagine del firmware da scaricare, e avvia l'aggiornamento del firmware sul dispositivo in modo asincrono:

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
}

Aggiungere il codice seguente per creare un'istanza del client:

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

Aggiungere il codice seguente a:

Aprire la connessione.
Inviare l'oggetto DeviceInfo.
Impostare un gestore per le proprietà desiderate.
Inviare le proprietà segnalate.
Registrare i gestori dei metodi diretti.
Avviare l'invio dei dati di telemetria.

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

Salvare le modifiche apportate al file remote_monitoring.js.
Eseguire il comando seguente al prompt dei comandi per avviare l'applicazione di esempio:
```
node remote_monitoring.js
```

Visualizzare la telemetria del dispositivo nel dashboard

Il dashboard nella soluzione di monitoraggio remoto consente di visualizzare la telemetria che i dispositivi inviano all'hub IoT.

Nel browser tornare al dashboard della soluzione di monitoraggio remoto e fare clic su Dispositivi nel pannello di sinistra per passare a Elenco dispositivi.
In Devices list (Elenco dispositivi) si noterà che lo stato del dispositivo è ora In esecuzione. Se non lo è, nel pannello Dettagli dispositivo fare clic su Attiva dispositivo.
Fare clic su Dashboard per tornare al dashboard e selezionare il dispositivo nell'elenco a discesa Dispositivo da visualizzare per visualizzarne i dati di telemetria. La telemetria dall'applicazione di esempio è di 50 unità per la temperatura interna, 55 unità per la temperatura esterna e 50 unità per l’umidità.

Richiamare un metodo sul dispositivo

Il dashboard nella soluzione di monitoraggio remoto consente di richiamare metodi sui dispositivi tramite l'hub IoT. Nella soluzione di monitoraggio remota, ad esempio, è possibile richiamare un metodo per simulare il riavvio di un dispositivo.

Nel dashboard della soluzione di monitoraggio remoto fare clic su Dispositivi nel pannello di sinistra per passare a Elenco dispositivi.
In Elenco dispositivi fare clic sull'ID del proprio dispositivo.
Nel pannello Dettagli dispositivo fare clic su Metodi.
Nel menu a discesa Metodi, selezionare InitiateFirmwareUpdate, quindi in FWPACKAGEURI immettere un URL fittizio. Fare clic su Richiama metodo per chiamare il metodo sul dispositivo.
Viene visualizzato un messaggio nella console che esegue il codice del dispositivo quando il dispositivo gestisce il metodo. I risultati del metodo vengono aggiunti alla cronologia nel portale delle soluzioni:

Passaggi successivi

L'articolo Personalizzazione delle soluzioni preconfigurate descrive alcuni modi per estendere questo esempio. Le estensioni possibili comprendono l'utilizzo di sensori reali e implementazione di comandi aggiuntivi.

Per altre informazioni sulle autorizzazioni visitare il sito azureiotsuite.com.

Condividi tramite