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

2017-11-02

Descrição geral do cenário

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

Temperatura externa
Temperatura interna
Humidade

Para simplificar, o código no dispositivo gera valores de amostra, mas recomendamos que você estenda a amostra conectando sensores reais ao seu dispositivo e enviando telemetria real.

O dispositivo também é capaz de responder a métodos invocados a partir 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, pode criar uma conta de avaliação gratuita em apenas alguns minutos. Para obter mais detalhes, veja 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.

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

O dispositivo que criar neste tutorial envia dados para uma instância da solução pré-configurada de monitorização remota . 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 a sua solução.
Na página Criar solução de monitorização remota, insira um Nome de Solução de sua escolha, selecione a Região em que deseja implantar e escolha a assinatura do Azure que deseja usar. Em seguida, clique em Criar solução.
Aguarde até que o processo de provisionamento seja concluído.

Advertência

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 terminar de usá-la para evitar cobranças desnecessárias. Pode remover completamente uma solução pré-configurada da sua subscrição visitando a página https://www.azureiotsolutions.com/.

Quando o processo de provisionamento para a solução de monitoramento remoto terminar, clique em Iniciar para abrir o painel da solução no navegador.

Painel de Solução

Configure o seu dispositivo na solução de monitorização remota

Observação

Se você já provisionou um dispositivo em sua solução, pode ignorar 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 no Hub IoT usando credenciais válidas. Você pode recuperar as credenciais do dispositivo no 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 Dispositivo Personalizado, clique em Adicionar novo.
Escolha Deixe-me definir meu próprio ID de dispositivo. Introduza um ID de Dispositivo, como mydevice, clique em Verificar ID para verificar se o nome não está a ser utilizado e, em seguida, clique em Criar para aprovisionar 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 Done (Concluído).
Selecione seu dispositivo na lista de dispositivos no painel da solução. Em seguida, no painel Detalhes do Dispositivo, clique em Ativar Dispositivo. O estado do seu dispositivo é agora Executando. A solução de monitoramento remoto agora pode receber telemetria do seu dispositivo e invocar métodos no dispositivo.

Criar uma solução node.js de exemplo

Certifique-se de que Node.js versão 0.11.5 ou posterior esteja instalada na sua máquina de desenvolvimento. Você pode executar node --version na linha de comando para verificar a versão.

Crie uma pasta chamada RemoteMonitoring em sua máquina 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 este 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 seguintes declarações de variáveis após as instruções require. Substitua os valores de espaço reservado [ID do dispositivo] e [Chave do dispositivo] pelos valores que você anotou para seu dispositivo no painel da solução de monitoramento remoto. Utilize o nome do host do Hub IoT no painel da solução para a substituição de [IoTHub Name]. Por exemplo, se o seu Nome de Host do Hub IoT 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 de 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 para usar 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 seguinte definição para os valores relatados de gêmeos do dispositivo. Esta definição inclui descrições dos métodos diretos suportados pelo 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"
    },
}

Adicione a seguinte função para manipular a chamada do método Reboot direct:

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 seguinte função para manipular a chamada direta do método InitiateFirmwareUpdate . Este 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 reportadas.
Registre manipuladores 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 telemetria de dispositivo no painel de controlo

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

No seu navegador, retorne ao painel da solução de monitorização remota e clique em Dispositivos no painel à esquerda para navegar até à lista de Dispositivos .
Na lista Dispositivos, deverá ver que o estado do seu dispositivo é Em Funcionamento. Caso contrário, clique em Ativar dispositivo no painel Detalhes do dispositivo.
Clique em Painel de Controlo para retornar ao painel de controlo, selecione o seu dispositivo no menu de seleção Dispositivo a Visualizar para ver a sua telemetria. A telemetria da aplicação da amostra é de 50 unidades para temperatura interna, 55 unidades para temperatura externa e 50 unidades para umidade.

Invoque um método no seu dispositivo

O painel na solução de monitoramento remoto permite que você invoque 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 em ID do dispositivo para o seu dispositivo na lista de Dispositivos.
No painel de detalhes do dispositivo , clique em Métodos .
Na lista suspensa Method, selecione InitiateFirmwareUpdatee, em seguida, 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 ao executar o código no dispositivo quando o dispositivo processa o método. Os resultados do método são adicionados ao histórico no portal da solução:

Próximos passos

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

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

Partilhar via