Conectar seu dispositivo à solução pré-configurada de monitoramento remoto (Node.js)

2017-11-02

Visão geral do cenário

Nesse cenário, você cria um dispositivo que envia a seguinte telemetria para a solução pré-configurada de monitoramento remoto:

Temperatura externa
Temperatura interna
Umidade

Para simplificar, o código no dispositivo gera valores de exemplo, mas incentivamos você a estender o exemplo conectando sensores reais ao seu dispositivo e enviando telemetria real.

O dispositivo também é capaz de responder aos métodos invocados do painel da solução e aos valores de propriedade desejados definidos no painel da solução.

Para concluir este tutorial, você precisa de uma conta ativa do Azure. Se não tiver uma conta, você poderá criar uma conta de avaliação gratuita em apenas alguns minutos. Para obter detalhes, consulte Avaliação gratuita do Azure.

Antes de começar

Antes de escrever qualquer código para seu dispositivo, você deve provisionar sua solução pré-configurada de monitoramento remoto e provisionar um novo dispositivo personalizado nessa solução.

Provisionar sua solução pré-configurada de monitoramento remoto

O dispositivo criado neste tutorial envia dados para uma instância da solução pré-configurada de monitoramento remoto . Se você ainda não provisionou a solução pré-configurada de monitoramento remoto em sua conta do Azure, use as seguintes etapas:

Na página https://www.azureiotsolutions.com/, clique em + para criar uma solução.
Clique em Selecionar no painel de monitoramento remoto para criar sua solução.
Na página Criar solução de monitoramento remoto , insira um nome de solução de sua escolha, selecione a Região na qual você deseja implantar e selecione a assinatura do Azure que deseja usar. Em seguida, clique em Criar solução.
Aguarde até que o processo de provisionamento seja concluído.

Aviso

As soluções pré-configuradas usam serviços faturáveis do Azure. Certifique-se de remover a solução pré-configurada de sua assinatura quando terminar de usá-la para evitar encargos desnecessários. Você pode remover completamente uma solução pré-configurada de sua assinatura visitando a https://www.azureiotsolutions.com/ página.

Quando o processo de provisionamento da solução de monitoramento remoto for concluído, clique em Iniciar para abrir o painel da solução no navegador.

Painel da solução

Provisione seu dispositivo na solução de monitoramento remoto

Observação

Se você já provisionou um dispositivo em sua solução, ignore esta etapa. Você precisa saber as credenciais do dispositivo ao criar o aplicativo cliente.

Para que um dispositivo se conecte à solução pré-configurada, ele deve se identificar ao Hub IoT usando credenciais válidas. Você pode recuperar as credenciais do dispositivo do painel da solução. Você inclui as credenciais do dispositivo em seu aplicativo cliente mais adiante neste tutorial.

Para adicionar um dispositivo à sua solução de monitoramento remoto, conclua as seguintes etapas no painel da solução:

No canto inferior esquerdo do painel, clique em Adicionar um dispositivo.
No painel do dispositivo personalizado , clique em Adicionar novo.
Escolha Deixe-me definir minha própria ID do Dispositivo. Insira uma ID do Dispositivo, como mydevice, clique em Verificar ID para verificar se o nome ainda não está em uso e clique em Criar para provisionar o dispositivo.
Anote as credenciais do dispositivo (ID do dispositivo, nome do host do Hub IoT e chave do dispositivo). Seu aplicativo cliente precisa desses valores para se conectar à solução de monitoramento remoto. Em seguida, clique em Concluído.
Selecione seu dispositivo na lista de dispositivos no painel da solução. Em seguida, no painel Detalhes do Dispositivo, clique em Habilitar Dispositivo. O estado do dispositivo agora está em execução. A solução de monitoramento remoto agora pode receber telemetria do seu dispositivo e invocar métodos no dispositivo.

Criar uma solução de exemplo node.js

Verifique se Node.js versão 0.11.5 ou posterior está instalada no computador de desenvolvimento. Você pode executar node --version na linha de comando para verificar a versão.

Crie uma pasta chamada RemoteMonitoring em seu computador de desenvolvimento. Navegue até esta pasta em seu ambiente de linha de comando.
Execute os seguintes comandos para baixar e instalar os pacotes necessários para concluir o aplicativo de exemplo:
```
npm init
npm install azure-iot-device azure-iot-device-mqtt --save
```
Na pasta RemoteMonitoring , crie um arquivo chamado remote_monitoring.js. Abra esse arquivo em um editor de texto.

No arquivo remote_monitoring.js, adicione as seguintes instruções de 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;

Adicione as declarações de variável a seguir após as instruções require. Substitua os valores dos espaços reservados [ID do Dispositivo] e [Chave do Dispositivo] pelos valores que você anotou para seu dispositivo no dashboard da solução de monitoramento remoto. Use o nome do host do Hub IoT no painel da solução para substituir [Nome do IoTHub]. Por exemplo, se o endereço do host do IoTHub for contoso.azure-devices.net, substitua [Nome do IoTHub] por contoso:
```
var connectionString = 'HostName=[IoTHub Name].azure-devices.net;DeviceId=[Device Id];SharedAccessKey=[Device Key]';
var deviceId = ConnectionString.parse(connectionString).DeviceId;
```
Adicione as seguintes variáveis para definir alguns dados de telemetria base:
```
var temperature = 50;
var humidity = 50;
var externalTemperature = 55;
```

Adicione a seguinte função auxiliar para imprimir os resultados da operação:

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

Adicione a seguinte função auxiliar a ser usada para randomizar os valores de telemetria:
```
function generateRandomIncrement() {
    return ((Math.random() * 2) - 1);
}
```

Adicione a seguinte definição para o objeto DeviceInfo que o dispositivo envia na inicialização:

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

Adicione a definição a seguir para os valores relatados do dispositivo gêmeo. Essa definição inclui descrições dos métodos diretos aos quais o dispositivo dá suporte:

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

Adicione a seguinte função para lidar com a chamada de método direto de reinicialização :

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

Adicione a função a seguir para lidar com a chamada de método direto InitiateFirmwareUpdate . Esse método direto usa um parâmetro para especificar o local da imagem de firmware a ser baixada e inicia a atualização de firmware no dispositivo de forma assíncrona:

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
}

Adicione o seguinte código para criar uma instância de cliente:

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

Adicione o seguinte código a:

Abra a conexão.
Envie o objeto DeviceInfo .
Configure um manipulador para as propriedades desejadas.
Enviar propriedades relatadas.
Registre controladores para os métodos diretos.
Comece a enviar 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'));
        });
    }
});

Salve as alterações no arquivo remote_monitoring.js.
Execute o seguinte comando em um prompt de comando para iniciar o aplicativo de exemplo:
```
node remote_monitoring.js
```

Exibir a telemetria do dispositivo no painel de controle

O painel na solução de monitoramento remoto permite exibir a telemetria que seus dispositivos enviam para o Hub IoT.

No navegador, retorne ao painel da solução de monitoramento remoto, clique em Dispositivos no painel esquerdo para navegar até a lista Dispositivos.
Na lista Dispositivos, você deverá ver que o status do dispositivo está em execução. Caso contrário, clique em Habilitar Dispositivo no painel Detalhes do Dispositivo .
Clique em Painel para retornar ao painel, selecione seu dispositivo na lista suspensa de Dispositivo para Exibir para visualizar sua telemetria. A telemetria do aplicativo de exemplo é de 50 unidades para temperatura interna, 55 unidades para temperatura externa e 50 unidades para umidade.

Invocar um método em seu dispositivo

O painel na solução de monitoramento remoto permite invocar métodos em seus dispositivos por meio do Hub IoT. Por exemplo, na solução de monitoramento remoto, você pode invocar um método para simular a reinicialização de um dispositivo.

No painel da solução de monitoramento remoto, clique em Dispositivos no painel esquerdo para navegar até a lista Dispositivos.
Clique na ID do Dispositivo para seu dispositivo na lista Dispositivos.
No painel detalhes do dispositivo , clique em Métodos.
Na lista suspensa Método, selecione InitiateFirmwareUpdate e, em FWPACKAGEURI, insira uma URL fictícia. Clique em Invocar Método para chamar o método no dispositivo.
Você verá uma mensagem no console executando o código do dispositivo quando o dispositivo manipula o método. Os resultados do método são adicionados ao histórico no portal da solução:

Próximas etapas

O artigo Personalizando soluções pré-configuradas descreve algumas maneiras de estender esse exemplo. As extensões possíveis incluem o uso de sensores reais e a implementação de comandos adicionais.

Você pode saber mais sobre as permissões no site azureiotsuite.com.

Compartilhar via