Samouczek: Tworzenie i łączenie aplikacji klienckiej z aplikacją usługi Azure IoT Central (Node.js)Tutorial: Create and connect a client application to your Azure IoT Central application (Node.js)

Ten artykuł dotyczy konstruktorów rozwiązań i deweloperów urządzeń.This article applies to solution builders and device developers.

W tym samouczku przedstawiono sposób, w jaki deweloper urządzenia nawiązuje połączenie Node.js aplikacji klienckiej z aplikacją IoT Central platformy Azure.This tutorial shows you how, as a device developer, to connect a Node.js client application to your Azure IoT Central application. Aplikacja Node.js symuluje zachowanie urządzenia czujnika środowiska.The Node.js application simulates the behavior of an environmental sensor device. Korzystając z przykładowego modelu możliwości urządzenia , można utworzyć szablon urządzenia w IoT Central.You use a sample device capability model to create a device template in IoT Central. Dodaj widoki do szablonu urządzenia, aby umożliwić operatorowi współpracujące z urządzeniem.You add views to the device template to enable an operator to interact with a device.

Ten samouczek zawiera informacje na temat wykonywania następujących czynności:In this tutorial, you learn how to:

  • Zaimportuj model możliwości urządzenia, aby utworzyć szablon urządzenia.Import a device capability model to create a device template.
  • Dodawanie domyślnych i niestandardowych widoków do szablonu urządzenia.Add default and custom views to a device template.
  • Opublikuj szablon urządzenia i Dodaj rzeczywiste urządzenie do aplikacji IoT Central.Publish a device template and add a real device to your IoT Central application.
  • Utwórz i uruchom kod urządzenia Node.js i sprawdź, czy jest on połączony z aplikacją IoT Central.Create and run the Node.js device code and see it connect to your IoT Central application.
  • Wyświetl symulowane dane telemetryczne wysyłane z urządzenia.View the simulated telemetry sent from the device.
  • Użyj widoku, aby zarządzać właściwościami urządzeń.Use a view to manage device properties.
  • Wywoływanie poleceń synchronicznych i asynchronicznych w celu sterowania urządzeniem.Call synchronous and asynchronous commands to control the device.

Wymagania wstępnePrerequisites

Do wykonania kroków opisanych w tym artykule potrzebne są:To complete the steps in this article, you need the following:

  • Aplikacja IoT Central platformy Azure utworzona przy użyciu szablonu aplikacji niestandardowej .An Azure IoT Central application created using the Custom application template. Aby uzyskać więcej informacji, zapoznaj się z przewodnikiem Szybki start dotyczącym tworzenia aplikacji.For more information, see the create an application quickstart. Aplikacja musi zostać utworzona w dniu lub po 07/14/2020.The application must have been created on or after 07/14/2020.
  • Komputer deweloperski z zainstalowanym Node.js w wersji 10.0.0 lub nowszej.A development machine with Node.js version 10.0.0 or later installed. node --versionAby sprawdzić swoją wersję, można uruchomić polecenie w wierszu polecenia.You can run node --version in the command line to check your version. W instrukcjach przedstawionych w tym samouczku założono, że uruchomiono polecenie Node w wierszu polecenia systemu Windows.The instructions in this tutorial assume you're running the node command at the Windows command prompt. Można jednak używać Node.js w wielu innych systemach operacyjnych.However, you can use Node.js on many other operating systems.

Tworzenie szablonu urządzeniaCreate a device template

Utwórz folder o nazwie environmental-sensor na komputerze lokalnym.Create a folder called environmental-sensor on your local machine.

Pobierz plik JSON modelu możliwości czujnika środowiska i Zapisz go w environmental-sensor folderze.Download the Environmental sensor capability model JSON file and save it in the environmental-sensor folder.

Użyj edytora tekstów, aby zamienić dwa wystąpienia z {YOUR_COMPANY_NAME_HERE} nazwą firmy w EnvironmentalSensorInline.capabilitymodel.json pobranym pliku.Use a text editor to replace the two instances of {YOUR_COMPANY_NAME_HERE} with your company name in the EnvironmentalSensorInline.capabilitymodel.json file you downloaded. Używaj tylko znaków a-z, A-Z, 0-9 i znaku podkreślenia.Use only the characters a-z, A-Z, 0-9, and underscore.

W aplikacji IoT Central platformy Azure Utwórz szablon urządzenia o nazwie czujnik środowiska , importując EnvironmentalSensorInline.capabilitymodel.json plik modelu możliwości urządzenia:In your Azure IoT Central application, create a device template called Environmental sensor by importing the EnvironmentalSensorInline.capabilitymodel.json device capability model file:

Szablon urządzenia z zaimportowanym modelem możliwości urządzenia

Model możliwości urządzenia obejmuje dwa interfejsy: standardowy interfejs informacji o urządzeniu i niestandardowy interfejs czujnika środowiska .The device capability model includes two interfaces: the standard Device Information interface and the custom Environmental Sensor interface. Interfejs czujnika środowiska definiuje następujące możliwości:The Environmental Sensor interface defines the following capabilities:

TypType Nazwa wyświetlanaDisplay Name OpisDescription
WłaściwośćProperty Stan urządzeniaDevice State Stan urządzenia.The state of the device. Dostępne są dwa stany online/offline.Two states online/offline are available.
Właściwość (zapisywalny)Property (writeable) Nazwa klientaCustomer Name Nazwa klienta, na którym aktualnie działa urządzenie.The name of the customer currently operating the device.
Właściwość (zapisywalny)Property (writeable) Poziom jasnościBrightness Level Poziom jasności światła na urządzeniu.The brightness level for the light on the device. Może być określona jako 1 (wysoka), 2 (średnia), 3 (niska).Can be specified as 1 (high), 2 (medium), 3 (low).
TelemetryTelemetry TemperaturaTemperature Bieżąca temperatura wykryta przez urządzenie.Current temperature detected by the device.
TelemetryTelemetry WilgotnośćHumidity Bieżąca wilgotność wykryta przez urządzenie.Current humidity detected by the device.
PolecenieCommand wskaźnikablink Rozpocznij miganie diody LED na urządzeniu dla danego interwału czasu.Begin blinking the LED on the device for given time interval.
PolecenieCommand wlaczaturnon Włącz diodę LED na urządzeniu.Turn on the LED on the device.
PolecenieCommand Wyłączanieturnoff Wyłącz diodę LED na urządzeniu.Turn off the LED on the device.
PolecenieCommand rundiagnosticsrundiagnostics To polecenie asynchroniczne uruchamia przebieg diagnostyczny na urządzeniu.This asynchronous command starts a diagnostics run on the device.

Aby dostosować sposób wyświetlania właściwości stanu urządzenia w aplikacji IoT Central, wybierz pozycję Dostosuj w szablonie urządzenia.To customize how the Device State property displays in your IoT Central application, select Customize in the device template. Rozwiń wpis stanu urządzenia , wprowadź online jako prawdziwą nazwę i w trybie offline jako wartość false.Expand the Device State entry, enter Online as the True name and Offline as the False name. Następnie Zapisz zmiany:Then save the changes:

Dostosowywanie szablonu urządzenia

Tworzenie widokówCreate views

Widoki umożliwiają współpracę z urządzeniami połączonymi z aplikacją IoT Central.Views let you interact with devices connected to your IoT Central application. Na przykład można mieć widoki, które wyświetlają dane telemetryczne, widoki, które wyświetlają właściwości i widoki umożliwiające edytowanie właściwości do zapisu i w chmurze.For example, you can have views that display telemetry, views that display properties, and views that let you edit writeable and cloud properties. Widoki są częścią szablonu urządzenia.Views are part of a device template.

Aby dodać widoki domyślne do szablonu urządzenia czujnika środowiska , przejdź do szablonu urządzenia, wybierz pozycję widokii wybierz kafelek Generuj widoki domyślne .To add some default views to your Environmental sensor device template, navigate to your device template, select Views, and select the Generate Default views tile. Upewnij się, że Przegląd i informacjewłączone, a następnie wybierz pozycję Generuj domyślne widoki pulpitu nawigacyjnego.Make sure Overview and About are On, and then select Generate default dashboard view(s). Masz teraz dwa domyślne widoki zdefiniowane w szablonie.You now have two default views defined in your template.

Interfejs czujnika środowiska obejmuje dwie właściwości do zapisu — nazwę klienta i poziom jasności.The Environmental Sensor interface includes two writeable properties - Customer Name and Brightness Level. Aby utworzyć widok, można użyć programu do edytowania następujących właściwości:To create a view, you can use to edit these properties:

  1. Wybierz pozycję widoki , a następnie wybierz kafelek Edytowanie urządzenia i danych w chmurze .Select Views and then select the Editing device and cloud data tile.

  2. Wprowadź Właściwości jako nazwę formularza.Enter Properties as the form name.

  3. Wybierz poziom jasności i właściwości nazwy klienta .Select the Brightness Level and Customer Name properties. Następnie wybierz pozycję Dodaj sekcję.Then select Add section.

  4. Zapisz zmiany.Save your changes.

Dodaj widok, aby włączyć edycję właściwości

Publikowanie szablonuPublish the template

Aby można było dodać urządzenie korzystające z szablonu urządzenia czujnika środowiska , należy je opublikować.Before you can add a device that uses the Environmental sensor device template, you must publish it.

W szablonie urządzenia wybierz pozycję Publikuj.In the device template, select Publish. Na panelu publikowanie tego szablonu urządzenia wybierz pozycję Publikuj.On the Publish this device template to the application panel, select Publish.

Aby sprawdzić, czy szablon jest gotowy do użycia, przejdź do strony urządzenia w aplikacji IoT Central.To check that the template is ready to use, navigate to the Devices page in your IoT Central application. Sekcja urządzenia zawiera listę opublikowanych urządzeń w aplikacji:The Devices section shows a list of the published devices in the application:

Opublikowane szablony na stronie urządzeń

Dodawanie rzeczywistego urządzeniaAdd a real device

W aplikacji IoT Central platformy Azure Dodaj rzeczywiste urządzenie do szablonu urządzenia utworzonego w poprzedniej sekcji:In your Azure IoT Central application, add a real device to the device template you created in the previous section:

  1. Na stronie urządzenia wybierz szablon urządzenia czujnika środowiska .On the Devices page, select the Environmental sensor device template.

  2. Wybierz pozycję + Nowe.Select + New.

  3. W oknie dialogowym Tworzenie nowego urządzenia upewnij się, że czujnik środowiska jest typem szablonu i który symuluje to urządzenie? jest ustawiony na wartość nie.In the Create a new device dialog, make sure that Environmental Sensor is the template type and that Simulate this device? is set to No.

  4. Następnie wybierz przycisk Utwórz.Then select Create.

Kliknij nazwę urządzenia, a następnie wybierz pozycję Połącz.Click on the device name, and then select Connect. Zanotuj informacje o połączeniu urządzenia w zakresie identyfikatorastrony połączenia urządzenia , identyfikatora urządzeniai klucza podstawowego.Make a note of the device connection information on the Device Connection page - ID scope, Device ID, and Primary key. Te wartości są potrzebne podczas tworzenia kodu urządzenia:You need these values when you create your device code:

Informacje dotyczące połączenia z urządzeniem

Tworzenie aplikacji Node.jsCreate a Node.js application

Poniższe kroki pokazują, jak utworzyć aplikację kliencką Node.js, która łączy się z rzeczywistym urządzeniem dodanym do aplikacji.The following steps show you how to create a Node.js client application that connects to the real device you added to the application. Ta aplikacja Node.js symuluje zachowanie rzeczywistego urządzenia.This Node.js application simulates the behavior of a real device.

  1. W środowisku wiersza polecenia przejdź do environmental-sensor folderu utworzonego wcześniej.In your command-line environment, navigate to the environmental-sensor folder you created previously.

  2. Aby zainicjować projekt Node.js i zainstalować wymagane zależności, uruchom następujące polecenia — Zaakceptuj wszystkie opcje domyślne podczas uruchamiania npm init :To initialize your Node.js project and install the required dependencies, run the following commands - accept all the default options when you run npm init:

    npm init
    npm install azure-iot-device azure-iot-device-mqtt azure-iot-provisioning-device-mqtt azure-iot-security-symmetric-key --save
    
  3. Utwórz plik o nazwie environmentalSensor.js w environmental-sensor folderze.Create a file called environmentalSensor.js in the environmental-sensor folder.

  4. Dodaj następujące require instrukcje na początku pliku environmentalSensor.js :Add the following require statements at the start of the environmentalSensor.js file:

    "use strict";
    
    // Use the Azure IoT device SDK for devices that connect to Azure IoT Central.
    var iotHubTransport = require('azure-iot-device-mqtt').Mqtt;
    var Client = require('azure-iot-device').Client;
    var Message = require('azure-iot-device').Message;
    var ProvisioningTransport = require('azure-iot-provisioning-device-mqtt').Mqtt;
    var SymmetricKeySecurityClient = require('azure-iot-security-symmetric-key').SymmetricKeySecurityClient;
    var ProvisioningDeviceClient = require('azure-iot-provisioning-device').ProvisioningDeviceClient;
    
  5. Dodaj następujące deklaracje zmiennych do pliku:Add the following variable declarations to the file:

    var provisioningHost = 'global.azure-devices-provisioning.net';
    var idScope = '{your Scope ID}';
    var registrationId = '{your Device ID}';
    var symmetricKey = '{your Primary Key}';
    var provisioningSecurityClient = new SymmetricKeySecurityClient(registrationId, symmetricKey);
    var provisioningClient = ProvisioningDeviceClient.create(provisioningHost, idScope, new ProvisioningTransport(), provisioningSecurityClient);
    var hubClient;
    
    var targetTemperature = 0;
    var ledOn = true;
    

    Aktualizowanie symboli zastępczych {your Scope ID} , {your Device ID} i {your Primary Key} z wartościami, które zostały wcześniej wykonane.Update the placeholders {your Scope ID}, {your Device ID}, and {your Primary Key} with the values you made a note of previously. W tym przykładzie zainicjowano targetTemperature do zera, można użyć bieżącego odczytu z urządzenia lub wartości z sznurka urządzenia.In this sample, you initialize targetTemperature to zero, you could use the current reading from the device or a value from the device twin.

  6. Aby wysłać symulowane dane telemetryczne do aplikacji IoT Central platformy Azure, Dodaj następującą funkcję do pliku:To send simulated telemetry to your Azure IoT Central application, add the following function to the file:

    // Send simulated device telemetry.
    function sendTelemetry() {
      var temp = targetTemperature + (Math.random() * 15);
      var humid = 70 + (Math.random() * 10);
      var data = JSON.stringify({
        temp: temp,
        humid: humid,
        });
      var message = new Message(data);
      hubClient.sendEvent(message, (err, res) => console.log(`Sent message: ${message.getData()}` +
        (err ? `; error: ${err.toString()}` : '') +
        (res ? `; status: ${res.constructor.name}` : '')));
    }
    

    Nazwy elementów telemetrycznych ( temp i humid ) muszą być zgodne z nazwami używanymi w szablonie urządzenia.The names of the telemetry items (temp and humid) must match the names used in the device template.

  7. Aby wysłać właściwości sznurka urządzenia do aplikacji IoT Central platformy Azure, Dodaj następującą funkcję do pliku:To send device twin properties to your Azure IoT Central application, add the following function to your file:

    // Send device twin reported properties.
    function sendDeviceProperties(twin, properties) {
      twin.properties.reported.update(properties, (err) => console.log(`Sent device properties: ${JSON.stringify(properties)}; ` +
        (err ? `error: ${err.toString()}` : `status: success`)));
    }
    

    IoT Central używa bliźniaczych reprezentacji urządzenia do synchronizowania wartości właściwości między urządzeniem a aplikacją IoT Central.IoT Central uses device twins to synchronize property values between the device and the IoT Central application. Wartości właściwości urządzenia używają właściwości zgłaszanych przez sznurek urządzeń.Device property values use device twin reported properties. Właściwości do zapisu używają zarówno raportowanych, jak i żądanych właściwości.Writeable properties use both device twin reported and desired properties.

  8. Aby zdefiniować i obsłużyć zapisywalne właściwości, na które odpowiada urządzenie, Dodaj następujący kod.To define and handle the writeable properties your device responds to, add the following code. Komunikat wysyłany przez urządzenie w odpowiedzi na aktualizację właściwości zapisywalnej musi zawierać av ac pola i.The message the device sends in response to the writeable property update must include the av and ac fields. adPole jest opcjonalne:The ad field is optional:

    // Add any writeable properties your device supports,
    // mapped to a function that's called when the writeable property
    // is updated in the IoT Central application.
    var writeableProperties = {
      'name': (newValue, callback) => {
          setTimeout(() => {
            callback(newValue, 'completed', 200);
          }, 1000);
      },
      'brightness': (newValue, callback) => {
        setTimeout(() => {
            callback(newValue, 'completed', 200);
        }, 5000);
      }
    };
    
    // Handle writeable property updates that come from IoT Central via the device twin.
    function handleWriteablePropertyUpdates(twin) {
      twin.on('properties.desired', function (desiredChange) {
        for (let setting in desiredChange) {
          if (writeableProperties[setting]) {
            console.log(`Received setting: ${setting}: ${desiredChange[setting]}`);
            writeableProperties[setting](desiredChange[setting], (newValue, status, code) => {
              var patch = {
                [setting]: {
                  value: newValue,
                  ad: status,
                  ac: code,
                  av: desiredChange.$version
                }
              }
              sendDeviceProperties(twin, patch);
            });
          }
        }
      });
    }
    

    Gdy operator ustawia właściwość do zapisu w aplikacji IoT Central, aplikacja używa odpowiedniej właściwości przędzy urządzenia do wysłania wartości do urządzenia.When the operator sets a writeable property in the IoT Central application, the application uses a device twin desired property to send the value to the device. Następnie urządzenie odpowiada za pomocą właściwości zgłoszonej przez urządzenie.The device then responds using a device twin reported property. Gdy IoT Central otrzymuje raportowaną wartość właściwości, aktualizuje widok właściwości ze stanem zsynchronizowane.When IoT Central receives the reported property value, it updates the property view with a status of synced.

    Nazwy właściwości ( name i brightness ) muszą być zgodne z nazwami używanymi w szablonie urządzenia.The names of the properties (name and brightness) must match the names used in the device template.

  9. Dodaj następujący kod, aby obsłużyć polecenia wysyłane z aplikacji IoT Central:Add the following code to handle the commands sent from the IoT Central application:

    // Setup command handlers
    function setupCommandHandlers(twin) {
    
      // Handle synchronous LED blink command with request and response payload.
      function onBlink(request, response) {
        console.log('Received synchronous call to blink');
        var responsePayload = {
          status: 'Blinking LED every ' + request.payload  + ' seconds'
        }
        response.send(200, responsePayload, (err) => {
          if (err) {
            console.error('Unable to send method response: ' + err.toString());
          } else {
            console.log('Blinking LED every ' + request.payload  + ' seconds');
          }
        });
      }
    
      // Handle synchronous LED turn on command
      function turnOn(request, response) {
        console.log('Received synchronous call to turn on LED');
        if(!ledOn){
          console.log('Turning on the LED');
          ledOn = true;
        }
        response.send(200, (err) => {
          if (err) {
            console.error('Unable to send method response: ' + err.toString());
          }
        });
      }
    
      // Handle synchronous LED turn off command
      function turnOff(request, response) {
        console.log('Received synchronous call to turn off LED');
        if(ledOn){
          console.log('Turning off the LED');
          ledOn = false;
        }
        response.send(200, (err) => {
          if (err) {
            console.error('Unable to send method response: ' + err.toString());
          }
        });
      }
    
      // Handle asynchronous sensor diagnostics command with response payload.
      function diagnostics(request, response) {
        console.log('Starting asynchronous diagnostics run...');
        response.send(202, (err) => {
          if (err) {
            console.error('Unable to send method response: ' + err.toString());
          } else {
            var repetitions = 3;
            var intervalID = setInterval(() => {
              console.log('Generating diagnostics...');
              if (--repetitions === 0) {
                clearInterval(intervalID);
                var properties = {
                  rundiagnostics: {
                    value: 'Diagnostics run complete at ' + new Date().toLocaleString()
                  }
                };
                sendDeviceProperties(twin, properties);
              }
            }, 2000);
          }
        });
      }
    
      hubClient.onDeviceMethod('blink', onBlink);
      hubClient.onDeviceMethod('turnon', turnOn);
      hubClient.onDeviceMethod('turnoff', turnOff);
      hubClient.onDeviceMethod('rundiagnostics', diagnostics);
    }
    

    Nazwy poleceń ( blink , turnon , turnoff i rundiagnostics ) muszą być zgodne z nazwami używanymi w szablonie urządzenia.The names of the commands (blink, turnon, turnoff, and rundiagnostics) must match the names used in the device template.

    Obecnie IoT Central nie korzysta ze schematu odpowiedzi zdefiniowanego w modelu możliwości urządzenia.Currently, IoT Central doesn't use the response schema defined in the device capability model. W przypadku polecenia synchronicznego ładunek odpowiedzi może być dowolnym prawidłowym kodem JSON.For a synchronous command, the response payload can be any valid JSON. W przypadku polecenia asynchronicznego urządzenie powinno natychmiast zwrócić odpowiedź 202, a następnie zgłosić aktualizację właściwości po zakończeniu pracy.For an asynchronous command, the device should return a 202 response immediately, followed by reported property update when the work is finished. Format raportowanej aktualizacji właściwości to:The format of the reported property update is:

    {
      [command name] : {
        value: 'response message'
      }
    }
    

    Operator może wyświetlać ładunek odpowiedzi w historii poleceń.An operator can view the response payload in the command history.

  10. Dodaj następujący kod, aby umożliwić nawiązanie połączenia z usługą Azure IoT Central i dołączyć funkcje do kodu klienta:Add the following code to complete the connection to Azure IoT Central and hook up the functions in the client code:

    // Handle device connection to Azure IoT Central.
    var connectCallback = (err) => {
      if (err) {
        console.log(`Device could not connect to Azure IoT Central: ${err.toString()}`);
      } else {
        console.log('Device successfully connected to Azure IoT Central');
    
        // Send telemetry to Azure IoT Central every 1 second.
        setInterval(sendTelemetry, 1000);
    
        // Get device twin from Azure IoT Central.
        hubClient.getTwin((err, twin) => {
          if (err) {
            console.log(`Error getting device twin: ${err.toString()}`);
          } else {
            // Send device properties once on device start up.
            var properties = {
              state: 'true',
              processorArchitecture: 'ARM',
              swVersion: '1.0.0'
            };
            sendDeviceProperties(twin, properties);
    
            handleWriteablePropertyUpdates(twin);
    
            setupCommandHandlers(twin);
          }
        });
      }
    };
    
    // Start the device (register and connect to Azure IoT Central).
    provisioningClient.register((err, result) => {
      if (err) {
        console.log('Error registering device: ' + err);
      } else {
        console.log('Registration succeeded');
        console.log('Assigned hub=' + result.assignedHub);
        console.log('DeviceId=' + result.deviceId);
        var connectionString = 'HostName=' + result.assignedHub + ';DeviceId=' + result.deviceId + ';SharedAccessKey=' + symmetricKey;
        hubClient = Client.fromConnectionString(connectionString, iotHubTransport);
    
        hubClient.open(connectCallback);
      }
    });
    

Uruchamianie aplikacji Node.jsRun your Node.js application

Aby uruchomić aplikację kliencką urządzenia, uruchom następujące polecenie w środowisku wiersza polecenia:To start the device client application, run the following command in your command-line environment:

node environmentalSensor.js

Możesz zobaczyć, że urządzenie nawiązuje połączenie z aplikacją IoT Central platformy Azure i zacznie wysyłać dane telemetryczne:You can see the device connects to your Azure IoT Central application and starts sending telemetry:

Uruchom aplikację kliencką

Jako operator w aplikacji IoT Central platformy Azure możesz:As an operator in your Azure IoT Central application, you can:

  • Wyświetlanie telemetrii wysyłanej przez urządzenie na stronie Przegląd :View the telemetry sent by the device on the Overview page:

    Wyświetlanie danych telemetrycznych

  • Wyświetl właściwości urządzenia na stronie informacje :View the device properties on the About page:

    Wyświetl właściwości

  • Zaktualizuj wartości zapisywalnych właściwości na stronie Właściwości :Update writeable property values on the Properties page:

    Aktualizuj właściwości

  • Wywołaj polecenia ze strony poleceń :Call the commands from the Commands page:

    Wywołanie migotania polecenia

    Wyświetl historię poleceń

Można sprawdzić, jak urządzenie reaguje na polecenia i aktualizacje właściwości:You can see how the device responds to commands and property updates:

Obserwuj aplikację kliencką

Wyświetlanie danych pierwotnychView raw data

Jako deweloper urządzenia możesz użyć widoku nieprzetworzone dane , aby sprawdzić pierwotne dane wysyłane przez urządzenie do IoT Central:As a device developer, you can use the Raw data view to examine the raw data your device is sending to IoT Central:

Nieprzetworzony widok danych

W tym widoku można wybrać kolumny do wyświetlenia i ustawić zakres czasu do wyświetlenia.On this view, you can select the columns to display and set a time range to view. W kolumnie dane niemodelowane są wyświetlane dane z urządzenia, które nie są zgodne z żadną definicją właściwości lub telemetrii w szablonie urządzenia.The Unmodeled data column shows data from the device that doesn't match any property or telemetry definitions in the device template.

Następne krokiNext steps

Jeśli wolisz korzystać z zestawu samouczków IoT Central i dowiedzieć się więcej na temat tworzenia rozwiązania IoT Central, zobacz:If you'd prefer to continue through the set of IoT Central tutorials and learn more about building an IoT Central solution, see:

Jako deweloper urządzenia znasz już podstawowe informacje dotyczące sposobu tworzenia urządzenia przy użyciu Node.js, ale Oto kilka sugerowanych następnych kroków:As a device developer, now that you've learned the basics of how to create a device using Node.js, some suggested next steps are to: