Ismerkedés az ikereszközökkel (Java)

Cikk
01/29/2024

Az ikereszközök JSON-dokumentumok, amelyek az eszközök állapotinformációit, például a metaadatokat, konfigurációkat és állapotokat tárolják. Az IoT Hub minden olyan eszközhöz megőrzi az ikereszközt, amely csatlakozik hozzá.

Feljegyzés

A cikkben ismertetett funkciók csak az IoT Hub standard szintjén érhetők el. Az alapszintű és standard/ingyenes IoT Hub-szintekről további információt a megoldáshoz megfelelő IoT Hub-szint kiválasztása című témakörben talál.

Az ikereszközök használata:

Tárolja az eszköz metaadatait a megoldás háttérrendszeréből.
Jelentse az aktuális állapotinformációkat, például az elérhető képességeket és feltételeket, például a használt kapcsolati módszert az eszközalkalmazásból.
Szinkronizálja a hosszan futó munkafolyamatok állapotát, például a belső vezérlőprogramot és a konfigurációs frissítéseket egy eszközalkalmazás és egy háttéralkalmazás között.
Az eszköz metaadatainak, konfigurációjának vagy állapotának lekérdezése.

Az ikereszközök szinkronizálásra, valamint eszközkonfigurációk és feltételek lekérdezésére lettek tervezve. Az ikereszközökkel kapcsolatos további információkért, beleértve az ikereszközök használatát is, olvassa el az ikereszközök ismertetése című témakört.

Az IoT Hubs az ikereszközöket tárolja, amelyek a következő elemeket tartalmazzák:

Címkék. Az eszköz metaadatait csak a megoldás háttérrendszere érheti el.
Kívánt tulajdonságok. A megoldás háttérrendszere által módosítható és az eszközalkalmazás által megfigyelhető JSON-objektumok.
Jelentett tulajdonságok. Az eszközalkalmazás által módosítható és a megoldás háttérrendszere által olvasható JSON-objektumok.

A címkék és tulajdonságok nem tartalmazhatnak tömböket, de beágyazott objektumokat is tartalmazhatnak.

Az alábbi ábra az ikereszközök szervezetét mutatja be:

Képernyőkép egy ikereszköz-koncepciódiagramról.

Emellett a megoldás háttérrendszere az összes fenti adat alapján lekérdezheti az ikereszközöket. Az ikereszközökkel kapcsolatos további információkért tekintse meg az ikereszközökkel kapcsolatos tudnivalókat. A lekérdezéssel kapcsolatos további információkért lásd az IoT Hub lekérdezési nyelvét.

Ez a cikk bemutatja, hogyan:

Szimulált eszközalkalmazás használatával jelentse a kapcsolati csatornáját az ikereszköz jelentett tulajdonságaként.
Lekérdezheti az eszközöket a háttéralkalmazásból a korábban létrehozott címkék és tulajdonságok szűrőinek használatával.

Ebben a cikkben két Java-konzolalkalmazást hoz létre:

add-tags-query: egy háttéralkalmazás, amely címkéket ad hozzá, és lekérdezi az ikereszközöket.
simulated-device: egy szimulált eszközalkalmazás, amely csatlakozik az IoT Hubhoz, és jelenti annak kapcsolati állapotát.

Feljegyzés

Az eszköz- és háttéralkalmazások készítéséhez elérhető SDK-eszközökről további információt az Azure IoT SDK-kban talál.

Előfeltételek

Egy IoT Hub. Hozzon létre egyet a parancssori felülettel vagy az Azure Portallal.
Az IoT Hubon regisztrált eszköz. Ha nincs eszköze az IoT Hubon, kövesse az eszköz regisztrálása című témakörben leírt lépéseket.
Java SE Fejlesztői készlet 8. A JDK 8 letöltéséhez győződjön meg arról, hogy a Hosszú távú támogatás alatt a Java 8-at választja.
Maven 3
Győződjön meg arról, hogy a 8883-as port nyitva van a tűzfalon. A cikkben szereplő eszközminta MQTT protokollt használ, amely a 8883-es porton keresztül kommunikál. Ez a port néhány vállalati és oktatási hálózati környezetben blokkolható. További információkért és a probléma megoldásának módjaiért lásd: Csatlakozás az IoT Hubhoz (MQTT).

Az IoT Hub kapcsolati sztring lekérése

Ebben a cikkben egy háttérszolgáltatást hoz létre, amely hozzáadja a kívánt tulajdonságokat egy ikereszközhöz, majd lekérdezi az identitásjegyzéket, hogy megtalálja az összes, ennek megfelelően frissített jelentett tulajdonságokkal rendelkező eszközt. A szolgáltatásnak szüksége van a szolgáltatás csatlakoztatási engedélyére az ikereszköz kívánt tulajdonságainak módosításához, és a beállításjegyzék olvasási engedélyére van szüksége az identitásjegyzék lekérdezéséhez. Nincs olyan alapértelmezett megosztott hozzáférési szabályzat, amely csak ezt a két engedélyt tartalmazza, ezért létre kell hoznia egyet.

Ha olyan megosztott hozzáférési szabályzatot szeretne létrehozni, amely szolgáltatás-kapcsolódási és beállításjegyzék-olvasási engedélyeket biztosít, és kapcsolati sztring szeretne kapni ehhez a szabályzathoz, kövesse az alábbi lépéseket:

Az Azure Portalon válassza ki az Erőforráscsoportokat. Válassza ki azt az erőforráscsoportot, ahol a központ található, majd válassza ki a központot az erőforrások listájából.
A központ bal oldali ablaktábláján válassza a Megosztott hozzáférési szabályzatok lehetőséget.
A szabályzatok listája feletti felső menüben válassza a Megosztott házirend hozzáférési szabályzat hozzáadása lehetőséget.
A jobb oldali Megosztott hozzáférési szabályzat hozzáadása panelen adjon meg egy leíró nevet a szabályzatnak, például serviceAndRegistryRead. Az Engedélyek területen válassza a Beállításjegyzék olvasása és a Service Connect, majd a Hozzáadás lehetőséget.
Válassza ki az új szabályzatot a szabályzatok listájából.
Válassza az Elsődleges kapcsolati sztring másolás ikont, és mentse az értéket.

További információ az IoT Hub megosztott hozzáférési szabályzatairól és engedélyeiről: Hozzáférés-vezérlés és engedélyek.

Jelentett tulajdonságokat frissíteni kívánó eszközalkalmazás létrehozása

Ebben a szakaszban létrehoz egy Java-konzolalkalmazást, amely myDeviceId azonosítóként csatlakozik a központhoz, majd frissíti az ikereszköz jelentett tulajdonságait, hogy meggyőződjön arról, hogy mobilhálózattal csatlakozik.

Az iot-java-twin-getstarted mappában hozzon létre egy Szimulált eszköz nevű Maven-projektet a parancssor következő parancsával:

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=simulated-device -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

A parancssorban keresse meg a szimulált eszköz mappát.
Szövegszerkesztővel nyissa meg a pom.xml fájlt a szimulált eszköz mappában, és adja hozzá a következő függőségeket a függőségi csomóponthoz. Ez a függőség lehetővé teszi, hogy az alkalmazás iot-device-client csomagjával kommunikáljon az IoT Hubbal.
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-device-client</artifactId>
  <version>1.17.5</version>
</dependency>
```
Feljegyzés

Az iot-device-client legújabb verzióját a Maven keresési funkciójával tekintheti meg.
Adja hozzá a következő függőséget a függőségi csomóponthoz . Ez a függőség egy NOP-t konfigurál az Apache SLF4J naplózási homlokzatához, amelyet az eszközügyfél SDK használ a naplózás implementálásához. Ez a konfiguráció nem kötelező, de ha kihagyja, figyelmeztetés jelenhet meg a konzolon az alkalmazás futtatásakor. Az eszközügyfél SDK-jában való naplózásról további információt az Azure IoT-eszköz SDK for Java-olvasási fájljának mintáiban talál.
```
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-nop</artifactId>
  <version>1.7.28</version>
</dependency>
```

Adja hozzá a következő buildcsomópontot a függőségi csomópont után. Ez a konfiguráció arra utasítja a Mavent, hogy a Java 1.8-at használja az alkalmazás létrehozásához:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.3</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Mentse és zárja be a pom.xml fájlt.
Szövegszerkesztővel nyissa meg a simulated-device\src\main\java\com\mycompany\app\App.java fájlt.

Adja hozzá a következő importálási utasításokat a fájlhoz:

import com.microsoft.azure.sdk.iot.device.*;
import com.microsoft.azure.sdk.iot.device.DeviceTwin.*;

import java.io.IOException;
import java.net.URISyntaxException;
import java.util.Scanner;

Adja hozzá a következő osztályszintű változókat az App osztályhoz. Cserélje le {yourdeviceconnectionstring} azt az eszközt, kapcsolati sztring, amikor regisztrált egy eszközt az IoT Hubon:
```
private static String connString = "{yourdeviceconnectionstring}";
private static IotHubClientProtocol protocol = IotHubClientProtocol.MQTT;
private static String deviceId = "myDeviceId";
```
Ez a mintaalkalmazás a protocol változót használja egy DeviceClient objektum példányának létrehozásakor.

Adja hozzá a következő metódust az alkalmazásosztályhoz az ikerfrissítésekkel kapcsolatos információk nyomtatásához:

protected static class DeviceTwinStatusCallBack implements IotHubEventCallback {
    @Override
    public void execute(IotHubStatusCode status, Object context) {
      System.out.println("IoT Hub responded to device twin operation with status " + status.name());
    }
  }

Cserélje le a fő metódus kódját a következő kódra:

Hozzon létre egy eszközügyfélt az IoT Hubbal való kommunikációhoz.
Hozzon létre egy eszközobjektumot az ikereszköz tulajdonságainak tárolásához.

DeviceClient client = new DeviceClient(connString, protocol);

// Create a Device object to store the device twin properties
Device dataCollector = new Device() {
  // Print details when a property value changes
  @Override
  public void PropertyCall(String propertyKey, Object propertyValue, Object context) {
    System.out.println(propertyKey + " changed to " + propertyValue);
  }
};

Adja hozzá a következő kódot a fő metódushoz egy connectivityType jelentett tulajdonság létrehozásához és az IoT Hubba való elküldéséhez:

try {
  // Open the DeviceClient and start the device twin services.
  client.open();
  client.startDeviceTwin(new DeviceTwinStatusCallBack(), null, dataCollector, null);

  // Create a reported property and send it to your IoT hub.
  dataCollector.setReportedProp(new Property("connectivityType", "cellular"));
  client.sendReportedProperties(dataCollector.getReportedProp());
}
catch (Exception e) {
  System.out.println("On exception, shutting down \n" + " Cause: " + e.getCause() + " \n" + e.getMessage());
  dataCollector.clean();
  client.closeNow();
  System.out.println("Shutting down...");
}

Adja hozzá a következő kódot a fő metódus végéhez. Az Enter-kulcsra való várakozás időt biztosít az IoT Hub számára az ikereszköz-műveletek állapotának jelentésére.
```
System.out.println("Press any key to exit...");

Scanner scanner = new Scanner(System.in);
scanner.nextLine();

dataCollector.clean();
client.close();
```
Módosítsa úgy a main metódus aláírását, hogy tartalmazza az alábbi kivételeket:
```
public static void main(String[] args) throws URISyntaxException, IOException
```
Mentse és zárja be a simulated-device\src\main\java\com\mycompany\app\App.java fájlt.
Hozza létre a szimulált eszköz alkalmazást, és javítsa ki a hibákat. A parancssorban keresse meg a szimulált eszköz mappát, és futtassa a következő parancsot:
```
mvn clean package -DskipTests
```

Szolgáltatásalkalmazás létrehozása, amely frissíti a kívánt tulajdonságokat és lekérdezi az ikerpéldányokat

Ebben a szakaszban egy Java-alkalmazást hoz létre, amely címkeként adja hozzá a hely metaadatait az ikereszközhöz a myDeviceId azonosítóval társított IoT Hubban. Az alkalmazás lekérdezi az IoT Hubot az USA-ban található eszközökhöz, majd lekérdezi a mobilhálózati kapcsolatot jelentéssel rendelkező eszközöket.

A fejlesztői gépen hozzon létre egy iot-java-twin-getstarted nevű üres mappát.

Az iot-java-twin-getstarted mappában hozzon létre egy Maven-projektet add-tags-query néven a következő paranccsal a parancssorban:

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=add-tags-query -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

A parancssorban keresse meg a add-tags-query mappát.
Szövegszerkesztővel nyissa meg a pom.xml fájlt a add-tags-query mappában, és adja hozzá a következő függőséget a függőségi csomóponthoz. Ez a függőség lehetővé teszi, hogy az alkalmazás iot-service-client csomagjával kommunikáljon az IoT Hubbal:
```
<dependency>
  <groupId>com.microsoft.azure.sdk.iot</groupId>
  <artifactId>iot-service-client</artifactId>
  <version>1.17.1</version>
  <type>jar</type>
</dependency>
```
Feljegyzés

Az iot-service-client legújabb verzióját a Maven keresési funkciójával tekintheti meg.

Adja hozzá a következő buildcsomópontot a függőségi csomópont után. Ez a konfiguráció arra utasítja a Mavent, hogy a Java 1.8-at használja az alkalmazás létrehozásához.

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-compiler-plugin</artifactId>
      <version>3.3</version>
      <configuration>
        <source>1.8</source>
        <target>1.8</target>
      </configuration>
    </plugin>
  </plugins>
</build>

Mentse és zárja be a pom.xml fájlt.
Szövegszerkesztővel nyissa meg a add-tags-query\src\main\java\com\mycompany\app\App.java fájlt.

Adja hozzá a következő importálási utasításokat a fájlhoz:

import com.microsoft.azure.sdk.iot.service.devicetwin.*;
import com.microsoft.azure.sdk.iot.service.exceptions.IotHubException;

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

Adja hozzá a következő osztályszintű változókat az App osztályhoz. Cserélje le {youriothubconnectionstring} az IoT Hub kapcsolati sztring az IoT Hub lekérése kapcsolati sztring.

public static final String iotHubConnectionString = "{youriothubconnectionstring}";
public static final String deviceId = "myDeviceId";

public static final String region = "US";
public static final String plant = "Redmond43";

Frissítse a főmetódus-aláírást , hogy tartalmazza a következő throws záradékot:
```
public static void main( String[] args ) throws IOException
```
Cserélje le a fő metódus kódját a következő kódra a DeviceTwin és a DeviceTwinDevice objektumok létrehozásához. A DeviceTwin objektum kezeli az IoT Hubbal folytatott kommunikációt. A DeviceTwinDevice objektum az ikereszközt jelöli annak tulajdonságaival és címkéivel:
```
// Get the DeviceTwin and DeviceTwinDevice objects
DeviceTwin twinClient = DeviceTwin.createFromConnectionString(iotHubConnectionString);
DeviceTwinDevice device = new DeviceTwinDevice(deviceId);
```

Adja hozzá a következő try/catch blokkot a fő metódushoz:

try {
  // Code goes here
} catch (IotHubException e) {
  System.out.println(e.getMessage());
} catch (IOException e) {
  System.out.println(e.getMessage());
}

Az ikereszköz régiójának frissítéséhez és az ikereszköz-címkék telepítéséhez adja hozzá a következő kódot a try blokkhoz:

// Get the device twin from IoT Hub
System.out.println("Device twin before update:");
twinClient.getTwin(device);
System.out.println(device);

// Update device twin tags if they are different
// from the existing values
String currentTags = device.tagsToString();
if ((!currentTags.contains("region=" + region) && !currentTags.contains("plant=" + plant))) {
  // Create the tags and attach them to the DeviceTwinDevice object
  Set<Pair> tags = new HashSet<Pair>();
  tags.add(new Pair("region", region));
  tags.add(new Pair("plant", plant));
  device.setTags(tags);

  // Update the device twin in IoT Hub
  System.out.println("Updating device twin");
  twinClient.updateTwin(device);
}

// Retrieve the device twin with the tag values from IoT Hub
System.out.println("Device twin after update:");
twinClient.getTwin(device);
System.out.println(device);

Az IoT Hub ikereszközeinek lekérdezéséhez adja hozzá a következő kódot a try blokkhoz az előző lépésben hozzáadott kód után. A kód két lekérdezést futtat. Minden lekérdezés legfeljebb 100 eszközt ad vissza.

// Query the device twins in IoT Hub
System.out.println("Devices in Redmond:");

// Construct the query
SqlQuery sqlQuery = SqlQuery.createSqlQuery("*", SqlQuery.FromType.DEVICES, "tags.plant='Redmond43'", null);

// Run the query, returning a maximum of 100 devices
Query twinQuery = twinClient.queryTwin(sqlQuery.getQuery(), 100);
while (twinClient.hasNextDeviceTwin(twinQuery)) {
  DeviceTwinDevice d = twinClient.getNextDeviceTwin(twinQuery);
  System.out.println(d.getDeviceId());
}

System.out.println("Devices in Redmond using a cellular network:");

// Construct the query
sqlQuery = SqlQuery.createSqlQuery("*", SqlQuery.FromType.DEVICES, "tags.plant='Redmond43' AND properties.reported.connectivityType = 'cellular'", null);

// Run the query, returning a maximum of 100 devices
twinQuery = twinClient.queryTwin(sqlQuery.getQuery(), 3);
while (twinClient.hasNextDeviceTwin(twinQuery)) {
  DeviceTwinDevice d = twinClient.getNextDeviceTwin(twinQuery);
  System.out.println(d.getDeviceId());
}

Mentse és zárja be a add-tags-query\src\main\java\com\mycompany\app\App.java fájlt
Hozza létre a add-tags-query alkalmazást, és javítsa ki a hibákat. A parancssorban keresse meg a add-tags-query mappát, és futtassa a következő parancsot:
```
mvn clean package -DskipTests
```

Az alkalmazások futtatása

Most már készen áll a konzolalkalmazások futtatására.

A add-tags-query mappában található parancssorban futtassa a következő parancsot az add-tags-query szolgáltatásalkalmazás futtatásához:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Láthatja az ikereszközhöz hozzáadott növény - és régiócímkéket . Az első lekérdezés visszaadja az eszközt, de a második nem.
A szimulált eszköz mappában lévő parancssorban futtassa a következő parancsot a connectivityType jelentett tulajdonságnak az ikereszközhöz való hozzáadásához:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Az add-tags-query mappában lévő parancssorban futtassa a következő parancsot az add-tags-query szolgáltatásalkalmazás második futtatásához:
```
mvn exec:java -Dexec.mainClass="com.mycompany.app.App"
```
Most, hogy az eszköz elküldte a connectivityType tulajdonságot az IoT Hubnak, a második lekérdezés visszaadja az eszközt.

Ebben a cikkben:

Eszköz metaadatai hozzáadva címkékként egy háttéralkalmazásból
Jelentett eszközkapcsolati információk az ikereszközben
Az ikereszköz adatainak lekérdezése SQL-szerű IoT Hub-lekérdezési nyelv használatával

Következő lépések

A következő tudnivalókat ismerheti meg:

Telemetria küldése eszközökről, lásd : Rövid útmutató: Telemetriai adatok küldése IoT Plug and Play-eszközről az Azure IoT Hubba
Eszközök konfigurálása az ikereszköz kívánt tulajdonságaival, lásd : Oktatóanyag: Eszközök konfigurálása háttérszolgáltatásból
Az eszközök interaktív vezérlése, például egy felhasználó által vezérelt alkalmazás ventilátorának bekapcsolása, lásd : Rövid útmutató: IoT Hubhoz csatlakoztatott eszköz vezérlése

Megosztás a következőn keresztül: