Připojení zařízení Raspberry Pi k akcelerátoru řešení pro vzdálené 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í pro vzdálené monitorování:

Teplota
Tlak
Vlhkost

Pro zjednodušení kód vygeneruje ukázkové telemetrické hodnoty pro Chiller. 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é na stránce 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 kód pro vaše zařízení, nasaďte akcelerátor řešení pro vzdálené monitorování a přidejte do řešení nové skutečné zařízení.

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

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

Po dokončení procesu nasazení řešení pro vzdálené 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 však 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 IoT Hub pomocí platných přihlašovacích údajů. Máte příležitost uložit připojovací řetězec zařízení, který obsahuje tyto přihlašovací údaje, když zařízení přidáte do řešení. Připojovací řetězec zařízení zahrnete do klientské aplikace později v tomto kurzu.

Pokud chcete přidat zařízení do řešení pro vzdálené 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 do akcelerátoru řešení pro vzdálené monitorování přidali skutečné zařízení a poznamenali jste si jeho 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 chladič odesílá hodnoty teploty, vlhkosti a tlaku.
Metody, které můžete naplánovat z řešení tak, 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í pro vzdálené 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 otestování nového simulovaného zařízení.

Požadovaný hardware

Stolní počítač, který umožňuje vzdálené připojení k příkazovému řádku na Raspberry Pi.

Microsoft IoT Starter Kit pro Raspberry Pi 3 nebo ekvivalentní komponenty. Tento kurz používá následující položky ze sady:

Raspberry Pi 3
MicroSD Karta (s NOOBS)
Kabel USB Mini
Ethernetový kabel

Požadovaný desktopový software

Ke vzdálenému přístupu k příkazovému řádku na Raspberry Pi potřebujete klienta SSH na stolním počítači.

Windows neobsahuje klienta SSH. Doporučujeme používat PuTTY.
Většina linuxových distribucí a Mac OS zahrnuje nástroj SSH příkazového řádku. Další informace najdete v tématu SSH Pomocí Linuxu nebo Mac OS.

Požadovaný software Raspberry Pi

Pokud jste to ještě neudělali, nainstalujte na Raspberry Pi Node.js verze 4.0.0 nebo novější. Následující kroky ukazují, jak nainstalovat Node.js v6 na Raspberry Pi:

Připojte se k Raspberry Pi pomocí ssh. Další informace najdete v tématu SSH (Secure Shell) na webu Raspberry Pi.
K aktualizaci Raspberry Pi použijte následující příkaz:
```
sudo apt-get update
```

Pomocí následujících příkazů odeberte z Raspberry Pi všechny existující instalace Node.js:

sudo apt-get remove nodered -y
sudo apt-get remove nodejs nodejs-legacy -y
sudo apt-get remove npm  -y

Pomocí následujícího příkazu stáhněte a nainstalujte Node.js v6 na Raspberry Pi:

curl -sL https://deb.nodesource.com/setup_6.x | sudo bash -
sudo apt-get install nodejs npm

Pomocí následujícího příkazu ověřte, že jste úspěšně nainstalovali Node.js verze 6.11.4:
```
node --version
```

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

Pomocí ssh připojení k Raspberry Pi proveďte následující kroky:

Vytvořte složku s názvem remotemonitoring ve vaší domovské složce na Raspberry Pi. Na příkazovém řádku přejděte do této složky:
```
cd ~
mkdir remotemonitoring
cd remotemonitoring
```
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 install async azure-iot-device azure-iot-device-mqtt
```
remotemonitoring Ve složce vytvořte soubor s názvemremote_monitoring.js. Otevřete tento soubor v textovém editoru. Na Raspberry Pi můžete použít nano textové editory.vi

Do souboruremote_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. Nahraďte hodnotu zástupného symbolu {device connection string} 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 použije k randomizaci 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 pro akce 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.
Odeslat ohlášené vlastnosti
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 souboruremote_monitoring.js .
Pokud chcete spustit ukázkovou aplikaci, spusťte na příkazovém řádku Raspberry Pi následující příkaz:
```
node remote_monitoring.js
```

Zobrazení telemetrie zařízení

Telemetrii odeslanou 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ě vykreslení telemetrie zařízení:
Pokud chcete změnit zobrazení telemetrie, zvolte Tlak :
Pokud chcete zobrazit diagnostické informace o zařízení, posuňte se dolů k diagnostice:

Act on your device

K vyvolání metod na vašich zařízeních použijte stránku Průzkumníka zařízení v řešení pro vzdálené monitorování. Například v zařízeních Chladič řešení pro vzdálené 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 svém 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í. Panel Úlohy zobrazuje typy metod společné 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.