Připojení zařízení k akcelerátoru řešení vzdáleného monitorování (Node.js)

Článek
01/24/2018

V tomto kurzu implementujete zařízení Chiller , které odesílá následující telemetrii do akcelerátoru řešení vzdáleného monitorování:

Teplota
Tlak
Vlhkost

Pro zjednodušení kód vygeneruje ukázkové telemetrické hodnoty pro chladič. Ukázku můžete rozšířit připojením skutečných senzorů k zařízení a odesláním skutečné telemetrie.

Ukázkové zařízení také:

Odešle do řešení metadata, která popisují jeho možnosti.
Reaguje na akce aktivované ze stránky Zařízení v řešení.
Reaguje na změny konfigurace odeslané ze stránky Zařízení v řešení.

K dokončení tohoto kurzu potřebujete mít aktivní účet Azure. Pokud účet nemáte, můžete si během několika minut vytvořit bezplatný zkušební účet. Podrobnosti najdete v článku Bezplatná zkušební verze Azure.

Než začnete

Než napíšete jakýkoli kód pro vaše zařízení, nasaďte akcelerátor řešení vzdáleného monitorování a přidejte do řešení nové skutečné zařízení.

Nasazení akcelerátoru řešení vzdáleného monitorování

Zařízení Chiller, které vytvoříte v tomto kurzu, odesílá data do instance akcelerátoru řešení vzdáleného monitorování. Pokud jste v účtu Azure ještě nezřídili akcelerátor řešení vzdáleného monitorování, přečtěte si téma Nasazení akcelerátoru řešení vzdáleného monitorování.

Po dokončení procesu nasazení řešení vzdáleného monitorování kliknutím na Spustit otevřete řídicí panel řešení v prohlížeči.

Řídicí panel řešení

Přidání zařízení do řešení pro vzdálené monitorování

Poznámka

Pokud jste už v řešení přidali zařízení, můžete tento krok přeskočit. Další krok ale vyžaduje připojovací řetězec vašeho zařízení. Připojovací řetězec zařízení můžete načíst z Azure Portal nebo pomocí nástroje az iot CLI.

Aby se zařízení mohlo připojit k akcelerátoru řešení, musí se identifikovat, aby se IoT Hub pomocí platných přihlašovacích údajů. Máte možnost uložit připojovací řetězec zařízení, který obsahuje tyto přihlašovací údaje, když zařízení přidáte do řešení. Do klientské aplikace zahrnete připojovací řetězec zařízení později v tomto kurzu.

Pokud chcete přidat zařízení do řešení vzdáleného monitorování, proveďte následující kroky na stránce Průzkumníka zařízení v řešení:

Zvolte + Nové zařízení a pak jako typ zařízení zvolte Skutečné:
Jako ID zařízení zadejte fyzický chladič . Zvolte možnosti symetrického klíče a automatického generování klíčů :
Zvolte Použít. Pak si poznamenejte hodnoty primárního klíče zařízení, primárního klíče a připojovacího řetězce :

Teď jste přidali skutečné zařízení do akcelerátoru řešení vzdáleného monitorování a poznamenali jste si připojovací řetězec zařízení. V následujících částech implementujete klientskou aplikaci, která používá připojovací řetězec zařízení pro připojení k vašemu řešení.

Klientská aplikace implementuje integrovaný model zařízení Chiller . Model zařízení akcelerátoru řešení určuje následující informace o zařízení:

Vlastnosti zařízení hlásí řešení. Například zařízení Chiller hlásí informace o jeho firmwaru a umístění.
Typy telemetrie, které zařízení odesílá do řešení. Například chladicí zařízení odesílá hodnoty teploty, vlhkosti a tlaku.
Metody, které můžete naplánovat z řešení, aby běžely na zařízení. Například zařízení Chiller musí implementovat metody Reboot, FirmwareUpdate, EmergencyValveRelease a IncreasePressure .

V tomto kurzu se dozvíte, jak připojit skutečné zařízení k akcelerátoru řešení vzdáleného monitorování. V tomto kurzu použijete Node.js, což je vhodná možnost pro prostředí s minimálními omezeními prostředků.

Pokud dáváte přednost simulaci zařízení, přečtěte si téma Vytvoření a testování nového simulovaného zařízení.

Vytvoření řešení Node.js

Ujistěte se, že na vývojovém počítači je nainstalovaná Node.js verze 4.0.0 nebo novější. Verzi můžete zkontrolovat node --version spuštěním na příkazovém řádku.

Vytvořte složku s názvem remotemonitoring na vývojovém počítači. Přejděte do této složky v prostředí příkazového řádku.
Pokud chcete stáhnout a nainstalovat balíčky, které potřebujete k dokončení ukázkové aplikace, spusťte následující příkazy:
```
npm init
npm install async azure-iot-device azure-iot-device-mqtt --save
```
remotemonitoring Ve složce vytvořte soubor s názvemremote_monitoring.js. Otevřete tento soubor v textovém editoru.

Do souboru remote_monitoring.js přidejte následující require příkazy:

var Protocol = require('azure-iot-device-mqtt').Mqtt;
var Client = require('azure-iot-device').Client;
var Message = require('azure-iot-device').Message;
var async = require('async');

Přidejte následující deklarace proměnných za příkazy require. Hodnotu zástupného symbolu {device connection string} nahraďte hodnotou, kterou jste si poznamenali pro zařízení, které jste zřídili v řešení pro vzdálené monitorování:
```
var connectionString = '{device connection string}';
```

Pokud chcete definovat některá základní telemetrická data, přidejte následující proměnné:

var temperature = 50;
var temperatureUnit = 'F';
var humidity = 50;
var humidityUnit = '%';
var pressure = 55;
var pressureUnit = 'psig';

Pokud chcete definovat některé hodnoty vlastností, přidejte následující proměnné:

var schema = "real-chiller;v1";
var deviceType = "RealChiller";
var deviceFirmware = "1.0.0";
var deviceFirmwareUpdateStatus = "";
var deviceLocation = "Building 44";
var deviceLatitude = 47.638928;
var deviceLongitude = -122.13476;
var deviceOnline = true;

Přidejte následující proměnnou, která definuje ohlášené vlastnosti, které se mají odeslat do řešení. Mezi tyto vlastnosti patří metadata, která se mají zobrazit ve webovém uživatelském rozhraní:

var reportedProperties = {
  "SupportedMethods": "Reboot,FirmwareUpdate,EmergencyValveRelease,IncreasePressure",
  "Telemetry": {
    [schema]: ""
  },
  "Type": deviceType,
  "Firmware": deviceFirmware,
  "FirmwareUpdateStatus": deviceFirmwareUpdateStatus,
  "Location": deviceLocation,
  "Latitude": deviceLatitude,
  "Longitude": deviceLongitude,
  "Online": deviceOnline
}

Pokud chcete vytisknout výsledky operace, přidejte následující pomocnou funkci:

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

Přidejte následující pomocnou funkci, která se má použít k náhodnému určení hodnot telemetrie:
```
function generateRandomIncrement() {
    return ((Math.random() * 2) - 1);
}
```

Přidejte následující obecnou funkci pro zpracování volání přímých metod z řešení. Funkce zobrazí informace o přímé metodě, která byla vyvolána, ale v této ukázce nijak nemění zařízení. Řešení používá přímé metody k jednání na zařízeních:

function onDirectMethod(request, response) {
  // Implement logic asynchronously here.
  console.log('Simulated ' + request.methodName);

  // Complete the response
  response.send(200, request.methodName + ' was called on the device', function (err) {
    if (err) console.error('Error sending method response :\n' + err.toString());
    else console.log('200 Response to method \'' + request.methodName + '\' sent successfully.');
  });
}

Přidejte následující funkci pro zpracování volání přímé metody FirmwareUpdate z řešení. Funkce ověří parametry předané v datové části přímé metody a asynchronně spustí simulaci aktualizace firmwaru:

function onFirmwareUpdate(request, response) {
  // Get the requested firmware version from the JSON request body
  var firmwareVersion = request.payload.Firmware;
  var firmwareUri = request.payload.FirmwareUri;

  // Ensure we got a firmware values
  if (!firmwareVersion || !firmwareUri) {
    response.send(400, 'Missing firmware value', function(err) {
      if (err) console.error('Error sending method response :\n' + err.toString());
      else console.log('400 Response to method \'' + request.methodName + '\' sent successfully.');
    });
  } else {
    // Respond the cloud app for the device method
    response.send(200, 'Firmware update started.', function(err) {
      if (err) console.error('Error sending method response :\n' + err.toString());
      else {
        console.log('200 Response to method \'' + request.methodName + '\' sent successfully.');

        // Run the simulated firmware update flow
        runFirmwareUpdateFlow(firmwareVersion, firmwareUri);
      }
    });
  }
}

Přidejte následující funkci pro simulaci dlouhotrvajícího toku aktualizace firmwaru, který hlásí průběh zpět do řešení:

// Simulated firmwareUpdate flow
function runFirmwareUpdateFlow(firmwareVersion, firmwareUri) {
  console.log('Simulating firmware update flow...');
  console.log('> Firmware version passed: ' + firmwareVersion);
  console.log('> Firmware URI passed: ' + firmwareUri);
  async.waterfall([
    function (callback) {
      console.log("Image downloading from " + firmwareUri);
      var patch = {
        FirmwareUpdateStatus: 'Downloading image..'
      };
      reportUpdateThroughTwin(patch, callback);
      sleep(10000, callback);
    },
    function (callback) {
      console.log("Downloaded, applying firmware " + firmwareVersion);
      deviceOnline = false;
      var patch = {
        FirmwareUpdateStatus: 'Applying firmware..',
        Online: false
      };
      reportUpdateThroughTwin(patch, callback);
      sleep(8000, callback);
    },
    function (callback) {
      console.log("Rebooting");
      var patch = {
        FirmwareUpdateStatus: 'Rebooting..'
      };
      reportUpdateThroughTwin(patch, callback);
      sleep(10000, callback);
    },
    function (callback) {
      console.log("Firmware updated to " + firmwareVersion);
      deviceOnline = true;
      var patch = {
        FirmwareUpdateStatus: 'Firmware updated',
        Online: true,
        Firmware: firmwareVersion
      };
      reportUpdateThroughTwin(patch, callback);
      callback(null);
    }
  ], function(err) {
    if (err) {
      console.error('Error in simulated firmware update flow: ' + err.message);
    } else {
      console.log("Completed simulated firmware update flow");
    }
  });

  // Helper function to update the twin reported properties.
  function reportUpdateThroughTwin(patch, callback) {
    console.log("Sending...");
    console.log(JSON.stringify(patch, null, 2));
    client.getTwin(function(err, twin) {
      if (!err) {
        twin.properties.reported.update(patch, function(err) {
          if (err) callback(err);
        });      
      } else {
        if (err) callback(err);
      }
    });
  }

  function sleep(milliseconds, callback) {
    console.log("Simulate a delay (milleseconds): " + milliseconds);
    setTimeout(function () {
      callback(null);
    }, milliseconds);
  }
}

Přidejte následující kód pro odesílání telemetrických dat do řešení. Klientská aplikace přidá do zprávy vlastnosti pro identifikaci schématu zprávy:

function sendTelemetry(data, schema) {
  if (deviceOnline) {
    var d = new Date();
    var payload = JSON.stringify(data);
    var message = new Message(payload);
    message.properties.add('iothub-creation-time-utc', d.toISOString());
    message.properties.add('iothub-message-schema', schema);

    console.log('Sending device message data:\n' + payload);
    client.sendEvent(message, printErrorFor('send event'));
  } else {
    console.log('Offline, not sending telemetry');
  }
}

Přidejte následující kód pro vytvoření instance klienta:

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

Přidejte následující kód:

Otevřete připojení.
Nastavte obslužnou rutinu pro požadované vlastnosti.
Odesílání ohlášených vlastností
Zaregistrujte obslužné rutiny pro přímé metody. Ukázka používá pro přímou metodu aktualizace firmwaru samostatnou obslužnou rutinu.

Začněte odesílat telemetrii.

client.open(function (err) {
if (err) {
  printErrorFor('open')(err);
} else {
  // 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) {
        // Handle desired properties set by solution
        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 all the method names we are interested in.
      // Consider separate handlers for each method.
      client.onDeviceMethod('Reboot', onDirectMethod);
      client.onDeviceMethod('FirmwareUpdate', onFirmwareUpdate);
      client.onDeviceMethod('EmergencyValveRelease', onDirectMethod);
      client.onDeviceMethod('IncreasePressure', onDirectMethod);
    }
  });

  // Start sending telemetry
  var sendDeviceTelemetry = setInterval(function () {
    temperature += generateRandomIncrement();
    pressure += generateRandomIncrement();
    humidity += generateRandomIncrement();
    var data = {
      'temperature': temperature,
      'temperature_unit': temperatureUnit,
      'humidity': humidity,
      'humidity_unit': humidityUnit,
      'pressure': pressure,
      'pressure_unit': pressureUnit
    };
    sendTelemetry(data, schema)
  }, 5000);

  client.on('error', function (err) {
    printErrorFor('client')(err);
    if (sendTemperatureInterval) clearInterval(sendTemperatureInterval);
    if (sendHumidityInterval) clearInterval(sendHumidityInterval);
    if (sendPressureInterval) clearInterval(sendPressureInterval);
    client.close(printErrorFor('client.close'));
  });
}
});

Uložte změny do souboru remote_monitoring.js .
Pokud chcete spustit ukázkovou aplikaci, spusťte na příkazovém řádku následující příkaz:
```
node remote_monitoring.js
```

Zobrazení telemetrie zařízení

Telemetrická data odeslaná ze zařízení můžete zobrazit na stránce Průzkumníka zařízení v řešení.

Vyberte zařízení, které jste zřídili v seznamu zařízení na stránce Průzkumník zařízení . Na panelu se zobrazí informace o vašem zařízení včetně grafu telemetrie zařízení:
Zvolte Tlak a změňte zobrazení telemetrie:
Pokud chcete zobrazit diagnostické informace o zařízení, posuňte se dolů k diagnostice:

Akce na vašem zařízení

K vyvolání metod na vašich zařízeních použijte stránku Průzkumníka zařízení v řešení vzdáleného monitorování. Například v zařízeních Chladič řešení vzdáleného monitorování implementují metodu restartování .

Zvolte Zařízení a přejděte na stránku Průzkumníka zařízení v řešení.
Vyberte zařízení, které jste zřídili v seznamu zařízení na stránce Průzkumník zařízení :
Pokud chcete zobrazit seznam metod, které můžete volat na zařízení, zvolte Úlohy a pak Metody. Pokud chcete naplánovat spuštění úlohy na více zařízeních, můžete v seznamu vybrat několik zařízení. Na panelu Úlohy se zobrazují typy běžných metod pro všechna vybraná zařízení.
Zvolte Restartovat, nastavte název úlohy na RebootPhysicalChiller a pak zvolte Použít:
Posloupnost zpráv se zobrazí v konzole s kódem zařízení, zatímco simulované zařízení zpracovává metodu.

Poznámka

Pokud chcete sledovat stav úlohy v řešení, zvolte Zobrazit stav úlohy.

Další kroky

Článek Přizpůsobení akcelerátoru řešení vzdáleného monitorování popisuje některé způsoby přizpůsobení akcelerátoru řešení.