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

Artigo
11/02/2017

Visão geral do cenário

Nesse cenário, você cria um dispositivo que envia a telemetria a seguir 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 é recomendável estender o exemplo conectando sensores reais aos dispositivos e enviando telemetria real.

O dispositivo também é capaz de responder aos métodos invocados no painel da solução e aos conjuntos de valores de propriedade desejada 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 o seu dispositivo, você precisa provisionar a 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 que você criar neste tutorial enviará dados a 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 Monitoramento remoto para criar a 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 a ser usada. 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 da sua assinatura quando tiver terminado com ela para evitar encargos desnecessários. Você pode remover completamente uma solução pré-configurada de sua assinatura acessando a página https://www.azureiotsolutions.com/.

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

Painel da solução

Provisionar o dispositivo na solução de monitoramento remoto

Observação

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

Para um dispositivo conectar-se à solução pré-configurada, ele deve identificar-se no Hub IoT usando credenciais válidas. Você pode recuperar as credenciais do dispositivo no painel da solução. Você pode incluir as credenciais do dispositivo em seu aplicativo cliente posteriormente neste tutorial.

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

No canto inferior esquerdo do painel, clique em Adicionar um dispositivo.
No painel Dispositivo Personalizado, clique em Adicionar novo.
Escolha Deixe-me definir minha própria ID de Dispositivo. Insira uma ID do Dispositivo como mydevice, clique em Verificar ID para verificar se esse nome ainda não está em uso e, em seguida, 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 do painel da solução. Em seguida, no painel Detalhes do Dispositivo, clique em Habilitar Dispositivo. O status do seu dispositivo agora é Executando. Agora a solução de monitoramento remoto poderá receber telemetria do seu dispositivo e invocar métodos nele.

Criar uma solução de exemplo do Node.js

Certifique-se de que o Node.js versão 0.11.5 ou posterior esteja instalado no computador de desenvolvimento. Você pode executar node --version na linha de comando para verificar a versão.

Crie uma pasta chamada RemoteMonitoring no computador de desenvolvimento. Navegue até essa pasta no ambiente de linha de comando.
Execute os seguintes comandos para baixar e instalar os pacotes de que você precisa para executar 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 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 do espaço reservado [Device Id] e [Device Key] pelos valores que você anotou para o seu dispositivo no painel da solução de monitoramento remoto. Use o nome de host do Hub IoT do painel da solução para substituir [IoTHub Name]. Por exemplo, se o nome de host do Hub IoT for contoso.azure-devices.net, substitua [Nome do HubIoT] 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 base de telemetria:
```
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 para usar para tornar os valores de telemetria aleatórios:
```
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 para o dispositivo gêmeo. Essa definição inclui descrições dos métodos diretos aos quais 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 direta 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.' );
        }
    });
}

Adicione a função a seguir para lidar com a chamada de método direta InitiateFirmwareUpdate. Esse método direto usa um parâmetro para especificar o local da imagem do firmware a ser baixado e inicia a atualização do 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 do cliente:

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

Adicione o seguinte código a:

Abra a conexão.
Enviar o objeto DeviceInfo.
Configure um manipulador para as propriedades desejadas.
Envie as propriedades relatadas.
Registre manipuladores para os métodos diretos.
Comece a enviar a 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 no prompt de comando para iniciar o aplicativo de exemplo:
```
node remote_monitoring.js
```

Exibir telemetria do dispositivo no painel

O painel da solução de monitoramento remoto permite que você exiba a telemetria que seus dispositivos enviam para o Hub IoT.

Em seu navegador, retorne para o painel da solução de monitoramento remoto, clique em Dispositivos no painel esquerdo para navegar até a Lista de dispositivos.
Na Lista de dispositivos, você deve ver que o status de seu dispositivo agora é Executando. Caso contrário, clique em Habilitar Dispositivo no painel de Detalhes do Dispositivo.
Clique em Painel para voltar ao painel, selecione seu dispositivo no menu suspenso Dispositivo para Exibição para exibir sua telemetria. A telemetria do aplicativo de exemplo é de 50 unidades de temperatura interna, 55 unidades de temperatura externa e 50 unidades de umidade.

Invocar um método no seu dispositivo

O painel da solução de monitoramento remoto permite que você invoque métodos nos seus dispositivos através 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 de dispositivos.
Clique em ID de dispositivo para seu dispositivo na Lista de dispositivos.
No painel Detalhes do dispositivo, clique em Métodos.
Na lista suspensa Método, selecione InitiateFirmwareUpdate e, em seguida, insira uma URL fictícia em FWPACKAGEURI. Clique em Invocar Método para chamar o método no dispositivo.
Você verá uma mensagem no console que está executando o código do dispositivo quando o dispositivo manipular o método. Os resultados do método serã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 este exemplo. Extensões possíveis incluem usar sensores reais e implementar comandos adicionais.

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

Compartilhar via