Conectar el dispositivo a la solución preconfigurada de supervisión remota (Node.js)

Artículo
11/02/2017

Información general de escenario

En este escenario, creará un dispositivo que envía la siguiente telemetría a la solución preconfigurada de supervisión remota:

Temperatura exterior
Temperatura interior
Humedad

Para simplificar, el código del dispositivo genera valores de ejemplo, pero le recomendamos que amplíe el ejemplo conectando sensores reales a su dispositivo y enviando telemetría real.

El dispositivo también puede responder a los métodos que se invocan desde el panel de la solución y los valores de propiedades deseadas establecidos en el panel de la solución.

Para completar este tutorial, deberá tener una cuenta activa de Azure. En caso de no tener cuenta, puede crear una de evaluación gratuita en tan solo unos minutos. Para obtener más información, consulte Evaluación gratuita de Azure.

Antes de comenzar

Antes de escribir ningún código para el dispositivo, debe aprovisionar la solución preconfigurada de supervisión remota y aprovisionar un nuevo dispositivo personalizado en esa solución.

Aprovisionar su solución preconfigurada de supervisión remota

El dispositivo que cree en este tutorial enviará datos a una instancia de la solución preconfigurada de supervisión remota. Si todavía no aprovisionó la solución preconfigurada de supervisión remota en su cuenta de Azure, use estos pasos:

En la página https://www.azureiotsolutions.com/, haga clic en + para crear una solución.
Haga clic en Seleccionar en el panel de supervisión remota para crear la solución.
En la página Create Remote monitoring solution (Crear solución de supervisión remota), escriba el nombre de solución que prefiera, seleccione la región en la que desea realizar la implementación y seleccione la suscripción de Azure que desea usar. Haga clic en Crear solución.
Espere a que finalice el proceso de aprovisionamiento.

Advertencia

Las soluciones preconfiguradas utilizan servicios de Azure facturables. Para evitar gastos innecesarios, asegúrese de quitar la solución preconfigurada de la suscripción cuando haya terminado. Para quitar completamente una solución preconfigurada de su suscripción, diríjase a la página https://www.azureiotsolutions.com/.

Cuando finalice el proceso de aprovisionamiento para la solución de supervisión remota, haga clic en Iniciar para abrir el panel de la solución en el explorador.

Panel de soluciones

Aprovisionar el dispositivo en la solución de supervisión remota

Nota

Si ya ha aprovisionado un dispositivo en la solución, puede omitir este paso. Debe conocer las credenciales del dispositivo cuando cree la aplicación cliente.

Para que un dispositivo se conecte a la solución preconfigurada, debe identificarse en Azure IoT Hub con credenciales válidas. Puede recuperar las credenciales del dispositivo desde el panel de la solución. Incluirá las credenciales del dispositivo en la aplicación de cliente más adelante en este tutorial.

Para agregar un dispositivo a su solución de supervisión remota, complete los pasos siguientes en el panel de la solución:

En la esquina inferior izquierda del panel, haga clic en Agregar un dispositivo.
En el panel Dispositivo personalizado, haga clic en Agregar nuevo.
Elija Permitirme definir mi propio id. de dispositivo. Especifique un id. de dispositivo, como mydevice, haga clic en Comprobar id. para comprobar que el nombre todavía no está en uso y, luego, haga clic en Crear para aprovisionar el dispositivo.
Anote las credenciales de dispositivo (id. de dispositivo, nombre de host de IoT Hub y clave de dispositivo). La aplicación cliente necesita estos valores para conectarse con la solución de supervisión remota. A continuación, haga clic en Hecho.
Seleccione el dispositivo en la lista de dispositivos del panel de la solución. Luego, en el panel Detalles del dispositivo, haga clic en Habilitar dispositivo. El estado del dispositivo ahora es En ejecución. La solución de supervisión remota ahora puede recibir telemetría desde el dispositivo e invocar métodos en el dispositivo.

Creación de una solución de ejemplo de node.js

Asegúrese de que tiene instalada la versión 0.11.5 o posterior de Node.js en la máquina de desarrollo. Para comprobar la versión, puede ejecutar node --version en la línea de comandos.

Cree una carpeta denominada RemoteMonitoring en la máquina de desarrollo. Vaya a esta carpeta en el entorno de línea de comandos.
Ejecute los comandos siguientes para descargar e instalar los paquetes que necesita para realizar la aplicación de ejemplo:
```
npm init
npm install azure-iot-device azure-iot-device-mqtt --save
```
En la carpeta RemoteMonitoring, cree un archivo llamado remote_monitoring.js. Abra este archivo en un editor de texto.

En el archivo remote_monitoring.js, agregue las siguientes instrucciones require:

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

Agregue las siguientes declaraciones de variable después de las instrucciones require . Sustituya los valores de marcador de posición [Device Id] y [Device Key] por los valores que anotó para el dispositivo en el panel de la solución de supervisión remota. Use el nombre de host de IoT Hub en el panel de la solución para sustituir [IoTHub Name]. Por ejemplo, si el nombre de host de IoT Hub es contoso.azure-devices.net, sustituya [IoTHub Name] por contoso:
```
var connectionString = 'HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]';
var deviceId = ConnectionString.parse(connectionString).DeviceId;
```
Agregue las siguientes variables para definir algunos datos de telemetría de base:
```
var temperature = 50;
var humidity = 50;
var externalTemperature = 55;
```

Agregue la función auxiliar siguiente para imprimir los resultados de la operación:

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

Agregue la siguiente función auxiliar para aleatorizar los valores de telemetría:
```
function generateRandomIncrement() {
    return ((Math.random() * 2) - 1);
}
```

Agregue la siguiente definición para el objeto DeviceInfo que envía el dispositivo al inicio:

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

Agregue la siguiente definición para los valores notificados por el dispositivo gemelo. Esta definición incluye descripciones de los métodos directos que admite el 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"
    },
}

Agregue la siguiente función para controlar la llamada al método directo 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.' );
        }
    });
}

Agregue la siguiente función para controlar la llamada al método directo InitiateFirmwareUpdate. Este método directo usa un parámetro para especificar la ubicación de la imagen de firmware que se va a descargar e inicia la actualización de firmware en el dispositivo de forma asincrónica:

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
}

Agregue el código siguiente para crear una instancia de cliente:

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

Agregue el siguiente código para:

Abrir la conexión.
Enviar el objeto DeviceInfo.
Configurar un controlador para propiedades deseadas.
Enviar propiedades notificadas.
Registrar controladores para métodos directos.
Empezar a enviar telemetría.

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

Guarde los cambios al archivo remote_monitoring.js.
Ejecute el siguiente comando en un símbolo del sistema para iniciar la aplicación de ejemplo:
```
node remote_monitoring.js
```

Ver la telemetría de dispositivo en el panel

El panel de la solución de supervisión remota permite ver la telemetría que los dispositivos envían a IoT Hub.

En el explorador, vuelva al panel de la solución de supervisión remota, haga clic en Dispositivos en el panel izquierdo para navegar hasta la lista de dispositivos.
En la lista de dispositivos, debería ver que el estado del dispositivo es En ejecución. Si no es así, haga clic en Habilitar dispositivo en el panel Detalles del dispositivo.
Haga clic en el Panel para volver a él, seleccione el dispositivo en la lista desplegable Device to View (Dispositivo para ver) para ver su telemetría. La telemetría de la aplicación de ejemplo es 50 unidades para la temperatura interior, 55 unidades para la temperatura exterior y 50 unidades para la humedad.

Invocar un método en el dispositivo

El panel de la solución de supervisión remota le permite invocar métodos en los dispositivos a través de IoT Hub. Por ejemplo, en la solución de supervisión remota, puede invocar un método para simular que se reinicia un dispositivo.

En el panel de la solución de supervisión remota, haga clic en Devices (Dispositivos) en el panel izquierdo para navegar a la lista de dispositivos.
Haga clic en Device ID (Id. de dispositivo) en el dispositivo de la lista de dispositivos.
En el panel Detalles del dispositivo, haga clic en Métodos.
En el menú desplegable Método, seleccione InitiateFirmwareUpdate y, luego, en FWPACKAGEURI, escriba una dirección URL ficticia. Haga clic en Invocar método para llamar al método en el dispositivo.
Puede ver un mensaje en la consola donde se ejecuta el código del dispositivo cuando el dispositivo controla el método. Los resultados del método se agregan al historial en el portal de la solución:

Pasos siguientes

En el artículo Personalización de soluciones preconfiguradas se describen algunas formas de ampliar este ejemplo. Entre las posibles extensiones se incluyen el uso de sensores reales y la implementación de comandos adicionales.

Puede obtener más información sobre los permisos en el sitio azureiotsuite.com.

Compartir a través de