Method for storing device based on unique identification of internet of things

Abstract

This invention relates to the field of enterprise management technology, specifically to a device inventory management method based on unique IoT identifiers. When multiple devices simultaneously trigger inventory management, edge computing nodes acquire unique IoT identifiers and construct an identifier relationship graph using the identifiers as nodes and communication handshake timestamps as edges. The graph is traversed to compare identifier strings, detecting conflicting nodes with the same identifier string. The physical address of the device access port and the local clock serial number of the conflicting nodes are extracted and concatenated to generate a transitional unique identifier. A mapping index table between the original identifier and the transitional identifier is established and sent to the central server, which stores the transitional identifier as the primary key for inventory based on the mapping index table. This invention avoids inventory data overwriting caused by identical unique IoT identifiers in concurrent inventory management scenarios, ensuring the isolation and integrity of multi-source device inventory data.

Description

Technical Field

[0001] This invention relates to the field of enterprise management technology, specifically to a method for warehousing devices based on unique identifiers in the Internet of Things (IoT). Background Technology

[0002] In IoT warehouse management, when multiple devices simultaneously connect to an edge computing node and trigger inbound registration, the conventional approach is for the edge computing node to extract the unique IoT identifier carried in the reported messages from each device, using this identifier as the sole credential for device identification. The edge computing node then encapsulates the obtained unique IoT identifier along with the corresponding device attribute data into an inbound request message, which is forwarded to the central server via the network. Upon receiving the inbound request message, the central server directly parses and extracts the unique IoT identifier, using it as the primary key in the database table to perform an insert operation, thus completing the persistent storage of device asset information.

[0003] Based on the existing technical solutions described above, in real-world scenarios where multiple devices connect concurrently, IoT devices from different manufacturers may have overlapping default identification encoding rules, or some devices may have their identification tags copied. When an edge computing node receives multiple inbound requests from devices carrying the same unique IoT identifier within the same time period, it will sequentially send multiple inbound request messages containing the same primary key to the central server. Since the central server directly uses the unique IoT identifier as the database primary key for writing, later write operations will overwrite the data records generated by earlier write operations, resulting in the loss of data for the device that initiated the inbound registration earlier in the database. This leads to the problem of inventory data being overwritten due to the same unique IoT identifier in concurrent inbound scenarios. Summary of the Invention

[0004] The purpose of this invention is to provide a method for adding devices to a database based on unique identifiers in the Internet of Things, which can solve the problems mentioned in the background art.

[0005] To achieve the above objectives, the technical solution adopted by the present invention is as follows:

[0006] A device entry method based on IoT unique identifiers is applied to edge computing nodes. The method includes: when multiple IoT devices trigger entry registration at the same time, obtaining the IoT unique identifiers reported by the multiple IoT devices.

[0007] Using the unique IoT identifier as a graph node and the communication handshake timestamp between IoT devices corresponding to adjacent graph nodes as graph edges, an identifier relationship graph for the current batch is constructed in memory.

[0008] Traverse the identifier relationship graph and compare the identifier strings of each graph node. When a conflicting node with the same identifier string is detected, extract the physical address of the device access port of the IoT device corresponding to the conflicting node and the local clock serial number of the edge computing node. Combine the physical address of the device access port and the local clock serial number according to the preset splicing rules to generate a transitional unique identifier.

[0009] A mapping index table is established between the original IoT unique identifier of the conflicting node and the transitional unique identifier. An ingestion request carrying the mapping index table is sent to the central server so that the central server stores the transitional unique identifier as the inventory primary key based on the mapping index table.

[0010] Preferably, before obtaining the unique IoT identifiers reported by the multiple IoT devices, the method further includes: monitoring multiple communication ports of the edge computing node, and determining that a concurrent database registration state is triggered when more than a preset number of connection request messages are received within a preset time window;

[0011] Parse the payload field of the connection request message and extract the byte sequence located at a fixed offset position in the payload field as an initial identifier;

[0012] The initial identifier is matched with a preset identifier format regular expression. When the match is successful, the initial identifier is confirmed as the unique identifier of the Internet of Things, and the communication port number and the receiving time of the connection request message are recorded.

[0013] Preferably, the communication handshake timestamps between IoT devices corresponding to adjacent graph nodes are used as graph edges to construct the identifier relationship graph of the current batch in memory, including: for any two IoT devices corresponding to the unique IoT identifiers, calculating the time difference between the first moment when the edge computing node sends a handshake response message to the first received IoT device and the second moment when it sends a handshake response message to the adjacent second received IoT device.

[0014] The time difference value is used as the edge attribute value of the graph edge;

[0015] An undirected graph data structure containing the graph nodes, graph edges, and edge attribute values ​​is created in the memory, and the undirected graph data structure is stored as the identifier relationship graph.

[0016] Preferably, traversing the identifier relationship graph and comparing the identifier strings of each graph node, when a conflicting node with the same identifier string is detected, includes: using a breadth-first search algorithm to traverse the graph nodes in the identifier relationship graph layer by layer;

[0017] During the traversal, the hash value of the identifier string of the currently visited graph node is compared with the hash value of the identifier strings of the visited graph nodes.

[0018] If the hash value of the identifier string of the currently visited graph node is the same as the hash value of the identifier string of any previously visited graph node, then both the currently visited graph node and the previously visited graph node are marked as the conflicting nodes, and the hierarchical position information of the conflicting nodes in the identifier relationship graph is recorded.

[0019] Preferably, the physical address of the device access port of the IoT device corresponding to the conflicting node and the local clock serial number of the edge computing node are extracted, and the physical address of the device access port and the local clock serial number are combined according to a preset splicing rule to generate a transitional unique identifier, including: extracting the source address field from the media access control message header of the IoT device corresponding to the conflicting node as the physical address of the device access port;

[0020] Read the current count value of the high-precision timer inside the edge computing node as the local clock sequence number;

[0021] The physical address of the device access port is converted to hexadecimal to obtain a first string, and the local clock serial number is converted to binary to obtain a second string;

[0022] The first string and the second string are concatenated using a preset XOR operator. The concatenated string is then hashed, and the calculated fixed-length hash value is used as the transition unique identifier.

[0023] Preferably, a mapping index table is established between the original IoT unique identifier and the transitional unique identifier of the conflicting node, and an entry request carrying the mapping index table is sent to the central server, including: generating key-value pair records in the local database of the edge computing node using the original IoT unique identifier as the index key and the transitional unique identifier as the index value.

[0024] All key-value pair records generated within the same batch are aggregated into the mapping index table;

[0025] The mapping index table is encapsulated into the request body of a Hypertext Transfer Protocol (HTTP) message, and a concurrent batch identifier field is added to the header of the HTTP message to obtain the database insertion request.

[0026] The database entry request is sent to the central server via a long-lived Transmission Control Protocol (TCP) connection between the edge computing node and the central server.

[0027] Preferably, the preset time window and the preset quantity threshold are determined by the following steps: statistically analyzing the distribution data of the number of connection request messages received by the edge computing node on each working day within a historical period;

[0028] Based on the distribution data of the number of received connection request messages, calculate the average time interval between two consecutive connection request messages;

[0029] The window length of the preset time window is determined by an integer multiple of the average time interval;

[0030] Multiply the maximum peak number in the distribution data of the number of received connection request messages by a preset security factor, and round down the product to determine the preset number threshold.

[0031] The window length and the preset quantity threshold are stored in the configuration file of the edge computing node.

[0032] Preferably, storing the undirected graph data structure as the identifier relationship graph includes: allocating a contiguous physical address space in the memory of the edge computing node;

[0033] In the contiguous physical address space, create an adjacency matrix array and a node pointer array;

[0034] The graph nodes in the undirected graph data structure are stored in the node pointer array, and the graph edges and their attribute values ​​are stored in the matrix intersection points of the adjacency matrix array corresponding to the graph nodes.

[0035] Configure a mutex lock for each intersection point of the adjacency matrix array, and acquire the mutex lock for the corresponding intersection point when updating the data in the adjacency matrix array.

[0036] Preferably, comparing the hash value of the identifier string of the currently visited graph node with the hash value of the identifier string of any visited graph node includes: calling a preset digest algorithm to calculate the hash value of the currently visited graph node and the identifier string of the visited graph node respectively, to obtain the hash value of the current node and the hash value of the historical node.

[0037] Perform a bitwise XOR operation between the current node hash value and the historical node hash value to obtain the difference feature value;

[0038] Determine whether the difference feature value is a zero vector;

[0039] If the difference feature value is not a zero vector, then extract the position number of the non-zero position in the difference feature value, and perform a set intersection operation on the position number and the preset fault-tolerant position set.

[0040] If the result of the intersection operation of the sets is an empty set, then it is determined that the hash value of the identifier string of the currently visited graph node is different from the hash value of the identifier string of the visited graph nodes.

[0041] Preferably, after generating key-value pair records in the local database of the edge computing node, the method further includes: obtaining the generation timestamp of the key-value pair records;

[0042] Create a time-sorted circular queue in the local database;

[0043] The key-value pair record is combined with the generated timestamp to form a queue element, and the queue element is inserted into the tail of the circular queue;

[0044] When the length of the circular queue reaches a preset queue capacity threshold, the head element of the circular queue is removed, and the original IoT unique identifier in the head element is read before removal.

[0045] Send a decommissioning notification message containing the original IoT unique identifier to the log server corresponding to the edge computing node.

[0046] Compared with the prior art, the beneficial effects of the present invention are as follows:

[0047] 1. This invention constructs an identifier relationship graph at edge computing nodes, using IoT unique identifiers as nodes and communication handshake timestamps as edges. By employing breadth-first search to traverse the graph and perform hash comparisons, it can detect conflicting nodes with the same identifier string in concurrent batches before the database entry request is sent to the central server. For detected conflicting nodes, the physical address of the device access port and the local clock sequence number are extracted, concatenated, converted, and hashed to generate an independent transitional unique identifier. A mapping index table between the original IoT unique identifier and the transitional unique identifier is then established. The central server stores inventory data using the transitional unique identifier as the primary key based on the mapping index table. This eliminates write conflicts caused by using the same IoT unique identifier directly as the database primary key, blocks the overwriting path of later-arriving data on earlier-arriving data, and ensures the isolation and integrity of inventory data from multiple sources during concurrent database entries.

[0048] 2. By calculating the average time interval and maximum peak number of connection requests based on historical periodic connection request distribution data, the judgment time window and quantity threshold for concurrent data entry are dynamically determined, ensuring that the identification of concurrent states closely matches the actual fluctuation characteristics of device access. The identifier relationship graph is stored in a contiguous physical address space containing an adjacency matrix array and a node pointer array, and mutex locks are configured for the intersection positions in the adjacency matrix array to avoid read / write contention when multiple threads update graph data. During the hash comparison process, the intersection operation of the bit sequence number of the difference feature value and the preset fault tolerance bit set is introduced to eliminate misjudgments caused by non-critical bit differences. A time-sorted circular queue is used to manage the lifecycle of the generated mapping key-value pair records. When the queue overflows, an eviction notice is sent to the log server, maintaining a stable occupancy of local storage resources on the edge computing nodes. Attached Figure Description

[0049] Figure 1 The main flowchart for the device entry method based on IoT unique identifiers;

[0050] Figure 2 Flowchart for concurrent data entry status determination and identifier extraction;

[0051] Figure 3 Flowcharts are constructed to identify the relationship graph;

[0052] Figure 4 This is a flowchart of the collision node detection process based on breadth-first search.

[0053] Figure 5 Generate a flowchart for the transitional unique identifier;

[0054] Figure 6 Flowchart for creating and managing the mapping index table's lifecycle. Detailed Implementation

[0055] Please refer to the attached document. Figure 1 This embodiment provides a device entry method based on IoT unique identifiers. Edge computing nodes are deployed in the entry operation area of ​​the smart warehouse, serving as core nodes for device access and data preprocessing. They have multiple types of IoT communication interfaces and can simultaneously connect to multiple IoT devices with wireless communication capabilities. These IoT devices include, but are not limited to, smart warehouse pallets, cargo RFID tags, entry operation terminals, and environmental monitoring sensors. The edge computing nodes establish a stable communication connection with the central server of the warehouse management system through a wide area network link. The edge computing nodes are configured with volatile memory media and local persistent storage media. The volatile memory media is used to build and process temporary data structures in real time, and the local persistent storage media is used to store configuration parameters and business data records.

[0056] When multiple IoT devices simultaneously trigger warehouse registration, the edge computing node obtains the unique IoT identifiers reported by these devices. Specifically, when multiple IoT devices simultaneously enter the signal coverage area of ​​the warehouse operation area and simultaneously initiate communication connection requests and warehouse registration instructions to the edge computing node, it is determined that multiple IoT devices have simultaneously triggered warehouse registration. After entering the warehouse area, the IoT devices first send a Beacon frame. Upon receiving the Beacon frame, the edge computing node replies with a ProbeResponse frame, completing the link layer handshake. Then, the device initiates a Transmission Control Protocol (TCP) connection, completing the three-way handshake process. Subsequently, the device sends a request message for the corresponding application layer protocol, including but not limited to MQTT, CoAP, and HTTP. The device's identity information is carried in a fixed field of the request message. In response to the warehouse registration instruction, the edge computing node returns a communication response message to each requesting IoT device and receives the message data reported by each IoT device after the connection is established. The unique IoT identifier of the corresponding IoT device is extracted from the fixed fields of the message data. The IoT unique identifier is a fixed-length string pre-installed inside the IoT device to represent the device's identity. Its encoding rules conform to the identification encoding specifications of the corresponding IoT device's industry. It is pre-installed when the device leaves the factory and cannot be modified through regular business operations. The IoT unique identifier includes, but is not limited to, EPC code, IMEI code, GS1 manufacturer code, and fixed identifiers derived from the device's MAC address.

[0057] Edge computing nodes use the unique IoT identifier as graph nodes and the communication handshake timestamps between IoT devices corresponding to adjacent graph nodes as graph edges to construct an identifier relationship graph for the current batch in memory. In this embodiment, the edge computing node maps the unique IoT identifiers corresponding to all IoT devices that have completed access in the current batch to independent graph nodes. Each graph node corresponds to one unique IoT identifier, and the attribute fields of the graph node include the complete string of the corresponding unique IoT identifier, the communication port number accessed by the device, and the timestamp information of the communication handshake completion. For two adjacent graph nodes in the current batch sorted by the communication handshake completion time, the association data of the communication handshake timestamps of the IoT devices corresponding to the two nodes is used as graph edges. The graph edges are used to represent the temporal association relationship between the two graph nodes. All graph nodes and graph edges together constitute the identifier relationship graph for the current batch. The identifier relationship graph is stored in the volatile memory of the edge computing node in the form of an undirected graph data structure, avoiding the impact of persistent storage IO overhead on concurrent processing timeliness. When devices in the current batch form a time sequence based on their handshake completion time, a graph edge is established between each pair of adjacent devices. The edge's attribute is the difference between the two handshake times. The constructed undirected graph is a chain structure, with all nodes connected in the access time sequence, providing a complete structural foundation for subsequent full traversal.

[0058] Edge computing nodes traverse the identifier relationship graph, comparing the identifier strings of each graph node. When a conflicting node with the same identifier string is detected, the physical address of the device access port of the IoT device corresponding to the conflicting node and the local clock serial number of the edge computing node are extracted. The physical address of the device access port and the local clock serial number are then combined according to a preset concatenation rule to generate a transitional unique identifier. Specifically, the edge computing node performs a full traversal of all graph nodes stored in memory according to a preset traversal rule. During the traversal, the identifier string carried by each visited graph node is compared for consistency with the identifier strings of all visited graph nodes. When the comparison results show that the identifier strings of two or more graph nodes are completely identical, all graph nodes in this group are marked as conflicting nodes. The IoT device corresponding to the conflicting node is the inbound device with the identifier conflict. For each marked conflict node, the edge computing node extracts the physical address of the device's access port from the header field of the corresponding IoT device's communication access message. This physical address is the physical address of the IoT device's network interface and is globally unique. Simultaneously, the edge computing node reads the current count value of its internal high-precision real-time clock to generate a local clock sequence number. This local clock sequence number is a monotonically increasing numerical sequence with no duplicate values. Following the concatenation rules pre-set in the local configuration file, the edge computing node performs format conversion and combination operations on the extracted device access port physical address and the local clock sequence number to generate a fixed-length transitional unique identifier. This transitional unique identifier is unique within the current batch and even across all inbound records.

[0059] Edge computing nodes establish a mapping index table between the original IoT unique identifiers and the transitional unique identifiers of the conflicting nodes, and send an inbound request carrying the mapping index table to the central server, so that the central server stores the transitional unique identifier as the primary key of the inventory based on the mapping index table. In this embodiment, for each conflicting node, the edge computing node establishes a correspondence between its corresponding original IoT unique identifier and the generated transitional unique identifier, and aggregates all correspondences into a mapping index table. The mapping index table contains the corresponding records of the original identifiers and transitional identifiers of all conflicting nodes in the current batch, and also includes auxiliary fields such as the unique batch number of the current batch, the inbound operation time, and the edge computing node number. The edge computing node encapsulates the mapping index table, the IoT unique identifiers of all non-conflicting nodes in the current batch, and the corresponding device attribute data into an inbound request, and sends it to the central server through a pre-established communication link. After receiving the inbound request, the central server parses the message, extracts the mapping index table and device inbound data, and for devices corresponding to non-conflicting nodes, directly uses their reported IoT unique identifier as the inventory primary key and writes the device attribute data into the warehouse inventory database. For devices corresponding to conflicting nodes, based on the corresponding relationship in the mapping index table, the transitional unique identifier is used as the inventory primary key, and the device attribute data is written into the warehouse inventory database. At the same time, the original IoT unique identifier is stored as an auxiliary index field in the corresponding data record, completing the inbound registration operation for all devices.

[0060] Table 1 Examples of node and edge attributes in the current batch identifier relationship graph

[0061] 1 EPC-202604240001 1713945600001 2 12 2 EPC-202604240002 1713945600013 1、3 12 3 EPC-202604240003 1713945600025 2、4 12 4 EPC-202604240002 1713945600037 3、5 12 5 EPC-202604240004 1713945600049 4 12

[0062] Table 1 shows an example of the node and edge attributes of the identifier relationship graph corresponding to the 5 IoT devices in the current batch. The node number corresponds to the unique IoT identifier, and the edge attribute value is the difference between the timestamps of the handshake completion between two adjacent nodes. This undirected graph structure can completely represent the access time sequence association of all devices in the current batch, providing a complete traversal object for subsequent identifier conflict detection. In this embodiment, by constructing an identifier relationship graph based on the device's unique identifier and access time sequence in the memory of the edge computing node, identifier conflict detection and processing are completed before the inbound data is uploaded to the central server. A unique transitional unique identifier is generated and a mapping relationship is established, allowing the central server to write inventory data based on conflict-free primary keys. This avoids data overwriting issues caused by identical identifiers and ensures the integrity of the inbound data.

[0063] refer to Figure 2In a preferred embodiment, before obtaining the unique IoT identifiers reported by the multiple IoT devices, the edge computing node continuously monitors multiple communication ports configured on itself. These communication ports include Ethernet physical ports, Wi-Fi access ports, and low-power wide-area network (LPWAN) communication ports, capable of simultaneously receiving connection request messages using different communication protocols. The edge computing node counts the received connection request messages within a preset time window. When the number of counted connection request messages exceeds a preset threshold, it determines that concurrent registration is triggered and initiates the subsequent identifier extraction and processing flow. If the number of counted connection request messages does not exceed the preset threshold, it is processed according to the conventional single-device registration process, without the need to construct an identifier relationship graph or conflict detection process.

[0064] The edge computing node parses the payload field of the connection request message and extracts a byte sequence located at a fixed offset position in the payload field as an initial identifier. Specifically, the edge computing node performs protocol parsing on each received connection request message, strips the header encapsulation fields, extracts the payload field, and reads a byte sequence of corresponding length from a fixed byte position in the payload field according to a preset identifier offset parameter. This byte sequence is then used as the initial identifier. Both the fixed offset and the byte sequence length are pre-set in the edge computing node's configuration file and match the identification encoding rules of the access device. For MQTT protocol connection messages, the fixed offset points to the starting position of the client identifier field; for RFID read messages, the fixed offset points to the starting position of the EPC encoding field; and for CoAP protocol request messages, the fixed offset points to the starting position of the device endpoint identifier field.

[0065] The edge computing node matches the initial identifier with a preset identifier format regular expression. When a match is successful, the initial identifier is confirmed as the unique identifier of the Internet of Things (IoT), and the communication port number and reception time of the connection request message are recorded. Specifically, the edge computing node calls a regular expression matching engine to perform a full match between the extracted initial identifier and the preset identifier format regular expression. The identifier format regular expression is generated according to the identifier encoding standard of the industry to which the IoT device belongs, and can verify whether the encoding format, length, and legal character range of the initial identifier meet the standard requirements. For EPCGID-96 encoding, the regular expression is set to ^[0-9A-F]{24}$; for IMEI code, the regular expression is set to ^[0-9]{15}$; and for GS1 manufacturer encoding, the regular expression is set to ^[0-9]{14}$. When the matching result is successful, the initial identifier is confirmed as a valid IoT unique identifier and stored in the temporary cache of the current batch. At the same time, auxiliary information such as the receiving communication port number, message reception time, and communication handshake completion time corresponding to the connection request message are recorded. When the matching result is unsuccessful, the initial identifier is discarded, an incorrect identifier format response message is returned to the corresponding IoT device, and the current registration process of the device is terminated.

[0066] The preset time window and the preset quantity threshold are determined through the following steps: Edge computing nodes statistically analyze the distribution data of connection request message reception counts for each workday within a historical period. The historical period is a preset continuous statistical period, preferably the past 30 calendar days. The connection request message reception count distribution data is the number of connection request messages received within each workday, divided into multiple time periods using a fixed time granularity, preferably 1 minute. Based on the connection request message reception count distribution data, the edge computing node calculates the average time interval between two consecutive connection request messages using the following formula:

[0067] in, The average time interval between two consecutive connection request messages, in milliseconds; This represents the total number of connection request messages collected within the historical period. For the first The time of receiving a connection request message, in milliseconds; For the first The reception time of each connection request message is measured in milliseconds. The edge computing node determines the window length of the preset time window as an integer multiple of the average time interval, calculated using the following formula: in, The window length for the preset time window, in milliseconds; The preset time window multiplier is preferably... The value is a positive integer, ranging from 5 to 20; The average time interval between two consecutive connection request messages, in milliseconds.

[0068] The edge computing node multiplies the maximum peak number in the distribution data of the number of received connection request messages by a preset security factor, and rounds down the product to determine the preset number threshold. The calculation formula is as follows: in, The preset quantity threshold; This represents the maximum peak number of connection request messages received within a single time period in the distribution data of the number of received connection request messages over a historical period. To preset a safety factor, preferably, The value range is 0.8 to 1.2; This is the floor function operator.

[0069] The edge computing node stores the window length and the preset quantity threshold in its configuration file. When the edge computing node starts up, it loads the parameters from the configuration file. During operation, it can re-collect historical data and update the parameters according to a preset update cycle, which is preferably 7 calendar days.

[0070] refer to Figure 3 Using the unique IoT identifier as a graph node and the communication handshake timestamps between IoT devices corresponding to adjacent graph nodes as graph edges, an identifier relationship graph for the current batch is constructed in memory. This includes: for any two IoT devices corresponding to the unique IoT identifiers, the edge computing node sorts all connected IoT devices in ascending order according to the sending time of the communication handshake response message, obtaining a device access time sequence. For any two adjacent IoT devices in the time sequence, the time difference between the first moment when the edge computing node sends a handshake response message to the first received IoT device and the second moment when it sends a handshake response message to the adjacent later received IoT device is calculated using the following formula: in, The first in the time series The and the first The time difference between the handshake response transmission times of each IoT device, in milliseconds; For edge computing nodes to the time sequence of the first The second moment when an IoT device sends a handshake response message, measured in milliseconds; For edge computing nodes to the time sequence of the first The first moment when an IoT device sends a handshake response message is measured in milliseconds.

[0071] The edge computing node uses the time difference value as the edge attribute value of the graph edge; an undirected graph data structure containing the graph node, the graph edge, and the edge attribute value is created in the memory, and the undirected graph data structure is stored as the identifier relationship graph.

[0072] Storing the undirected graph data structure as the identifier relationship graph includes: allocating contiguous physical address space in the memory of the edge computing nodes; the size of the contiguous physical address space is dynamically adjusted according to the number of devices connected in the current batch. The adjustment rule is to calculate the storage space required for the adjacency matrix based on the square of the number of nodes in the current batch, and then add the storage space required for the node pointer array to obtain the total allocated space size, avoiding waste or insufficiency of memory space. In the contiguous physical address space, an adjacency matrix array and a node pointer array are created; the length of the node pointer array is consistent with the number of graph nodes in the current batch, and each element in the array corresponds to a memory address pointer of a graph node, allowing for quick location of the corresponding graph node data through the array index. The adjacency matrix array is a two-dimensional square matrix, and the order of the square matrix is ​​consistent with the number of graph nodes. Line 1 The position of the intersection of the columns of the matrix corresponds to the position of the first column. The graph node and the first The graph edges between graph nodes are represented by the value stored at the intersection of the matrix, which is the edge attribute value of the corresponding graph edge. If there are no graph edges between two graph nodes, the value stored at the intersection of the matrix is ​​a preset invalid value. Preferably, the invalid value is -1.

[0073] Furthermore, a mutex lock is configured for each intersection position of the adjacency matrix array. This mutex lock is an exclusive lock in the thread synchronization mechanism. When updating data in the adjacency matrix array, the mutex lock for the corresponding matrix intersection position is acquired, and the mutex lock is released after the data update operation is completed. In multi-threaded concurrent processing scenarios, when multiple threads simultaneously update the same matrix intersection position of the adjacency matrices, they must first acquire the mutex lock for the corresponding position. If acquisition fails, the thread enters a blocked state, waiting for the lock to be released before proceeding. This ensures that only one thread is allowed to hold the mutex lock for the same matrix intersection position at any given time, avoiding read / write contention and data inconsistency issues caused by multi-threaded concurrent updates of graph data.

[0074] Table 2 Example of Historical Periodic Connection Request Message Reception Quantity Distribution Statistics

[0075] 1 2026-03-2509:00-09:01 12 50 no 1 2026-03-2510:00-10:01 28 21 yes 2 2026-03-2609:30-09:31 15 40 no 2 2026-03-2614:00-14:01 32 18 yes 3 2026-03-2711:00-11:01 18 33 no 3 2026-03-2715:30-15:31 25 24 no 4 2026-03-2816:00-16:01 30 20 yes

[0076] Table 2 shows a statistical example of the distribution of connection request message reception quantity over 4 working days in the historical period. The statistical granularity is 1 minute. The peak time marker is used to identify the peak number of connection requests in a single time period. Based on this statistical data, the average time interval and the maximum peak number in the historical period can be calculated, thereby determining the preset time window and preset quantity threshold for concurrent data entry status judgment, so that the judgment parameters fit the device access fluctuation characteristics in actual business.

[0077] In this embodiment, the judgment parameters for concurrent data entry status are dynamically determined by historical access data, which can accurately identify concurrent data entry scenarios and avoid false triggering or missed triggering. By extracting fixed offsets and validating regular expressions, valid IoT unique identifiers can be accurately obtained. By storing the identifier relationship graph in a contiguous memory space through an adjacency matrix and a node pointer array, and configuring a mutex lock to ensure data consistency during concurrent read and write operations, the processing efficiency of graph construction and traversal is improved, and data anomalies caused by multi-threaded operations are avoided.

[0078] refer to Figure 4 In a preferred embodiment, the identifier relationship graph is traversed, and the identifier strings of each graph node are compared. When a conflicting node with the same identifier string is detected, the process includes: the edge computing node using a breadth-first search algorithm to traverse the graph nodes in the identifier relationship graph layer by layer. Specifically, the edge computing node selects a preset starting node in the identifier relationship graph. The starting node is the graph node with the earliest communication handshake completion time in the current batch. The starting node is added to the traversal queue, and a set of visited nodes is created to record the graph nodes that have been traversed. The traversal queue is implemented using a first-in-first-out linked queue to avoid the expansion overhead of the array queue. The set of visited nodes is implemented using a hash set, which can determine whether a node has been visited in O(1) time complexity, improving the traversal processing efficiency. During the traversal, the currently visited graph node is taken from the head of the traversal queue and added to the set of visited nodes. At the same time, all adjacent nodes of the node are obtained. Nodes that are not added to the set of visited nodes and not added to the traversal queue are added to the tail of the traversal queue. The above queue operation is repeated until the traversal queue is empty, thus completing the full traversal of all graph nodes in the identification relationship graph.

[0079] During the traversal, the edge computing node compares the hash value of the identifier string of the currently visited graph node with that of the previously visited graph nodes. If the hash value of the identifier string of the currently visited graph node is the same as that of any previously visited graph node, both the currently visited graph node and the previously visited graph nodes are marked as conflicting nodes, and the hierarchical position information of the conflicting node in the identifier relationship graph is recorded. The hierarchical position information is the level of the node during the breadth-first search traversal, with the starting node at level 0, the adjacent nodes of the starting node at level 1, and so on. The hierarchical information is used to characterize the access sequence of nodes, providing a timing reference for subsequent conflict handling.

[0080] The hash value of the identifier string of the currently visited graph node is compared with the hash value of the identifier string of any previously visited graph node. This includes: the edge computing node calling a preset digest algorithm to calculate the hash value of the current node and the hash value of the previously visited graph nodes using a preset digest algorithm, respectively, to obtain the hash value of the current node and the hash value of the historical node. The preset digest algorithm is a secure hash algorithm, preferably the SHA-256 digest algorithm, which can convert an identifier string of arbitrary length into a fixed-length 256-bit hash value with an extremely low collision probability. The calculation formula is as follows: in, The hash value of the current node corresponding to the identifier string of the currently visited graph node; The hash value of the historical node corresponding to the identifier string of the visited graph node; This is the identifier string for the currently visited graph node; The identifier string for the visited graph nodes; This is the SHA-256 digest algorithm operation function.

[0081] The edge computing node performs a bitwise XOR operation between the current node hash value and the historical node hash value to obtain a difference feature value. The calculation formula is as follows: in, The difference feature value is obtained by bitwise XOR operation between the current node's hash value and the historical node's hash value, and is a 256-bit binary vector; The bitwise XOR operator returns 0 when corresponding bits are the same and 1 when corresponding bits are different. Edge computing nodes determine whether the difference feature value is a zero vector using the following formula: in, The first differential eigenvalue The binary value of a bit takes the value of 0 or 1; This is the bit sequence number, with a value range of 0 to 255, where 0 is the least significant bit and 255 is the most significant bit.

[0082] If the summation result is 0, meaning the difference feature value is a zero vector, then the hash value of the identifier string of the currently visited graph node is determined to be exactly the same as the hash value of the identifier string of the previously visited graph node, and a conflict node marking operation is performed. If the difference feature value is not a zero vector, then the non-zero bits in the difference feature value are extracted, and the bit indices are intersected with a preset set of fault-tolerant bits. Specifically, when the difference feature value is not a zero vector, it indicates that there is at least one bit difference between the current node's hash value and the historical node's hash value. In this case, all binary bits of the difference feature value are traversed, and the bit indices corresponding to all bits with a value of 1 are extracted to form a set of difference bit indices. The preset fault-tolerant bit set is a set of bit indices pre-installed in the edge computing node configuration file. These bit indices correspond to non-critical differences in the hash value due to encoding format compatibility issues. Differences in these bit indices do not indicate differences in the core content of the identifier string. For RFID tags from specific manufacturers, some reserved bits in their EPC encoding are randomly padded bits, changing with each power-on. The hash value bit indices corresponding to these reserved bits are pre-calculated and added to the fault-tolerant bit set to avoid misjudgments caused by differences in reserved bits. The formula for calculating the intersection of sets is: in, The result of the intersection operation between the set of difference bit indices and the set of fault-tolerant bits; The set of differential bit indices, consisting of the bit indices corresponding to the non-zero bits in the differential eigenvalues; This is a pre-defined set of fault-tolerant bits; This is the intersection operator for sets.

[0083] If the result of the set intersection operation is an empty set, meaning that the set of difference bit indices and the set of fault-tolerant bits do not have any common bit indices, it indicates that all differences in hash values ​​come from non-fault-tolerant bits. Therefore, the hash value of the identifier string of the currently accessed graph node is different from the hash value of the identifier string of the already accessed graph node, and it is not marked as a conflict node. If the result of the set intersection operation is completely consistent with the set of difference bit indices, meaning that all difference bits belong to the set of fault-tolerant bits, it indicates that all differences in hash values ​​come from preset fault-tolerant bits. Therefore, the hash value of the identifier string of the currently accessed graph node is the same as the hash value of the identifier string of the already accessed graph node, and it is marked as a conflict node.

[0084] Table 3. Examples of Identifier String Hash Comparison and Collision Node Determination Results

[0085] 1 EPC-202604240001 a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890 none empty set no 0 2 EPC-202604240002 f9e8d7c6b5a43210f9e8d7c6b5a43210f9e8d7c6b5a43210f9e8d7c6b5a43210 none empty set no 1 3 EPC-202604240003 1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef none empty set no 2 4 EPC-202604240002 f9e8d7c6b5a43210f9e8d7c6b5a43210f9e8d7c6b5a43210f9e8d7c6b5a43210 none empty set yes 3 5 EPC-202604240004 0987654321fedcba0987654321fedcba0987654321fedcba0987654321fedcba [3,7] {3,7} no 4 6 EPC-202604240005 567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234 [12,18] {12,18} no 5

[0086] Table 3 shows examples of hash comparison and conflict node determination results for each node's identifier string during the breadth-first search traversal of the identifier relationship graph. The preset fault tolerance bit set is {3,7,12,18}, and the non-zero index of the difference feature value is the bit position corresponding to the hash value difference. The intersection operation result is the intersection of the difference bit index set and the preset fault tolerance bit set. When the intersection operation result is completely consistent with the difference bit index set, it is determined to be a non-conflicting node. When the difference feature value is zero, it is determined to be a conflicting node. This process can accurately identify conflicting nodes with completely consistent core content of the identifier string, while eliminating misjudgments caused by fault tolerance bit differences.

[0087] In this embodiment, the breadth-first search algorithm is used to traverse the identifier relationship graph layer by layer, which ensures that all nodes in the current batch are completely visited without omission. Hash value comparison is used instead of character-by-character comparison, which improves the processing efficiency of identifier consistency verification. By verifying the intersection of bit operations on the difference feature values ​​and the fault-tolerant bit set, misjudgments caused by non-critical bit differences can be eliminated, improving the accuracy of conflict node detection and avoiding misprocessing of legitimate identifiers.

[0088] refer to Figure 5 In a preferred embodiment, the physical address of the device access port of the IoT device corresponding to the conflicting node and the local clock sequence number of the edge computing node are extracted. The physical address of the device access port and the local clock sequence number are combined according to a preset concatenation rule to generate a transitional unique identifier. This includes: the edge computing node extracting the source address field from the header of the media access control message of the IoT device corresponding to the conflicting node as the physical address of the device access port; the media access control message is a Layer 2 data message exchanged when the IoT device and the edge computing node establish a communication connection, and its header source address field is the 48-bit physical address of the device's network interface, which is globally unique and cannot be repeated. The edge computing node reads the current count value of a high-precision timer inside the edge computing node as the local clock sequence number; the high-precision timer is a hardware timer inside the edge computing node, with a counting frequency of not less than 1MHz, and the count value monotonically increases with time, ensuring that there is no repeated value within the device's operating cycle, thus ensuring that the local clock sequence numbers corresponding to multiple conflicting nodes triggered at the same time have nanosecond-level differences and avoiding repeated value acquisition.

[0089] The edge computing node performs a hexadecimal conversion on the physical address of the device access port to obtain a first string, and a binary conversion on the local clock serial number to obtain a second string. Specifically, the 48-bit physical address of the device access port is split into groups of 4 bits and converted into corresponding hexadecimal characters to obtain a first string of length 12. The local clock serial number is converted into a binary string, and the high-order bits of the binary string are padded with zeros to fix its length at 64 bits, resulting in a second string of length 64. The edge computing node concatenates the first string and the second string using a preset XOR operator, performs a hash calculation on the concatenated string, and uses the calculated fixed-length hash value as the transitional unique identifier.

[0090] The specific conversion and calculation process is as follows: First, the first string is converted into the corresponding binary sequence, and the calculation formula is: in, The 48-bit binary sequence obtained by converting the physical address of the device's access port; The first string obtained by converting the physical address of the device's access port; This is a conversion function for converting hexadecimal strings to binary sequences.

[0091] The 48-bit binary sequence obtained after conversion is padded with zeros to make its length match the length of the second string. The calculation formula is as follows: in, It is a binary sequence padded with zeros and extended. To pad the input binary sequence with zeros at the higher bits to achieve the target length. The function; The target length is preferably 64.

[0092] Perform a bitwise XOR operation between the expanded binary sequence and the binary sequence corresponding to the second string to complete the concatenation operation. The calculation formula is as follows: in, The binary sequence obtained by XOR concatenation; The fixed-length binary sequence obtained by converting the local clock sequence number has a length that is equal to... The lengths are consistent; This is the bitwise XOR operator. A hash calculation is performed on the concatenated binary sequence to obtain a fixed-length transitional unique identifier. The calculation formula is: in, The generated transitional unique identifier is a fixed-length hash value of 256 bits; This is the SHA-256 digest algorithm operation function.

[0093] refer to Figure 6Through the above calculations, it is ensured that the transitional unique identifier corresponding to each conflicting node is globally unique, without duplication, and has a fixed length to meet the format requirements of database primary keys. A mapping index table is established between the original IoT unique identifier and the transitional unique identifier of the conflicting node, and an ingestion request carrying the mapping index table is sent to the central server. This includes: the edge computing node using the original IoT unique identifier as the index key and the transitional unique identifier as the index value to generate key-value pair records in its local database; the local database is a key-value persistent database, preferably implemented using LevelDB or RocksDB, which has high throughput and low latency characteristics, adapts to the hardware resource limitations of the edge computing node, supports high-concurrency read and write operations, and can quickly complete the writing and querying of key-value pair records. The edge computing node aggregates all the key-value pair records generated in the same batch into the mapping index table; the mapping index table also includes auxiliary fields such as the unique batch identifier of the current batch, the ingestion operation timestamp, the unique number of the edge computing node, and the total number of conflicting nodes, for the central server to trace and manage the mapping relationship.

[0094] The edge computing node encapsulates the mapping index table into the request body of a Hypertext Transfer Protocol (HTTP) message and adds a concurrent batch identifier field to the header of the HTTP message to obtain the database insertion request. Specifically, the mapping index table is serialized and encoded using JSON format, and the serialized string is written into the request body of an HTTP POST request. An X-Batch-ID field is added to the header of the HTTP request, which is a unique batch identifier for the current batch and is used by the central server to associate database insertion requests in the same batch. A Content-Type field with the value application / json is also added to the header, declaring the data format of the request body. The edge computing node sends the database insertion request to the central server through a long-lived Transmission Control Protocol (TCP) connection between the edge computing node and the central server. This long-lived TCP connection is a TCP connection pre-established between the edge computing node and the central server at startup. After the connection is established, it remains alive through heartbeat messages, eliminating the need to re-establish a connection for each database insertion request, reducing communication overhead, and improving data transmission efficiency. After receiving the inbound request, the central server parses the request body of the HTTP message, extracts the mapping index table, and for conflicting nodes recorded in the mapping index table, uses the transitional unique identifier as the primary key of the inventory database, writes the corresponding device attribute data into the database, and stores the original IoT unique identifier as an auxiliary index field to ensure that the corresponding device inventory data can be queried through the original IoT unique identifier in the future.

[0095] After generating key-value pair records in the local database of the edge computing node, the edge computing node obtains the generation timestamp of the key-value pair record; the generation timestamp is the moment the key-value pair record is written to the local database, accurate to milliseconds. The edge computing node creates a time-sorted circular queue in the local database; the circular queue is a fixed-length first-in-first-out queue implemented using a circular array. The queue length is calculated by the offset between the head pointer and the tail pointer to avoid the overhead of element movement. When the tail pointer reaches the end of the array, it automatically wraps back to the beginning of the array to achieve circular storage. The elements in the queue are arranged in ascending order of generation timestamp, with the head element being the element with the earliest generation time and the tail element being the element with the latest generation time. The edge computing node combines the key-value pair record with the generation timestamp to form a queue element and inserts the queue element into the tail of the circular queue; when the length of the circular queue reaches a preset queue capacity threshold, the head element of the circular queue is removed, and the original IoT unique identifier in the head element is read before removal. The preset queue capacity threshold is pre-set in the configuration file of the edge computing node and can be adjusted according to the capacity of the local storage medium to ensure that the storage usage of the local database remains at a stable level. The edge computing node sends a retirement notification message containing the original IoT unique identifier to the log server corresponding to the edge computing node; the retirement notification message also includes fields such as the generation timestamp of the retired key-value pair record, the transition unique identifier, and the edge computing node number, and is published to a specified topic on the log server using the MQTT protocol. The log server subscribes to the topic, and after receiving the message, writes the data into the log database for permanent storage, ensuring that the retired mapping relationship is traceable and avoiding data loss.

[0096] Table 4. Example of the mapping index table structure between the original IoT unique identifier and the transitional unique identifier.

[0097] EPC-202604240002 f9e8d7c6b5a43210f9e8d7c6b5a43210f9e8d7c6b5a43210f9e8d7c6b5a43210 1713945600037 ETH2 BATCH-20260424-001 EPC-202604240002 a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890a1b2c3d4e5f67890 1713945600049 WIFI1 BATCH-20260424-001 EPC-202604240005 1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef 1713945600061 LORA3 BATCH-20260424-001 EPC-202604240005 0987654321fedcba0987654321fedcba0987654321fedcba0987654321fedcba 1713945600073 ETH1 BATCH-20260424-001 EPC-202604240006 567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234 1713945600085 WIFI2 BATCH-20260424-001

[0098] Table 4 shows an example of the mapping index table structure between the original IoT unique identifier and the transitional unique identifier for the current batch of goods entering the warehouse. The index key is the original IoT unique identifier reported by the conflicting node, and the index value is the generated transitional unique identifier with uniqueness. Through this mapping index table, the central server can accurately obtain the inventory primary key corresponding to the conflicting node, complete the writing of conflict-free goods entering the warehouse, and at the same time realize the traceability query of device data through the original IoT unique identifier.

[0099] In this embodiment, a globally unique transitional unique identifier is generated by XORing the physical address of the device access port with the local clock serial number and performing a hash calculation, thus eliminating the possibility of primary key conflicts at the source. A mapping index table is constructed using key-value pair records and encapsulated in an HTTP message for transmission via a TCP long connection, ensuring the complete and reliable transmission of the mapping relationship. A circular queue is used to manage the lifecycle of the mapping records stored locally, and an eviction notice is sent to the log server when the queue overflows, maintaining the stable occupation of local storage resources of the edge computing node and ensuring the traceability of the entire lifecycle of the mapping records.

Claims

1. A method for device entry into a database based on unique IoT identifiers, characterized in that, Applied to edge computing nodes, the method includes: when multiple IoT devices simultaneously trigger inbound registration, obtaining the unique IoT identifier reported by the multiple IoT devices; Using the unique IoT identifier as a graph node and the communication handshake timestamp between IoT devices corresponding to adjacent graph nodes as graph edges, an identifier relationship graph for the current batch is constructed in memory. Traverse the identifier relationship graph and compare the identifier strings of each graph node. When a conflicting node with the same identifier string is detected, extract the physical address of the device access port of the IoT device corresponding to the conflicting node and the local clock serial number of the edge computing node. Combine the physical address of the device access port and the local clock serial number according to the preset splicing rules to generate a transitional unique identifier. A mapping index table is established between the original IoT unique identifier of the conflicting node and the transitional unique identifier. An ingestion request carrying the mapping index table is sent to the central server so that the central server stores the transitional unique identifier as the inventory primary key based on the mapping index table.

2. The device entry method based on IoT unique identifiers according to claim 1, characterized in that, Before obtaining the unique IoT identifiers reported by the multiple IoT devices, the method further includes: monitoring multiple communication ports of the edge computing node, and determining that a concurrent database registration state is triggered when more than a preset number of connection request messages are received within a preset time window. Parse the payload field of the connection request message and extract the byte sequence located at a fixed offset position in the payload field as an initial identifier; The initial identifier is matched with a preset identifier format regular expression. When the match is successful, the initial identifier is confirmed as the unique identifier of the Internet of Things, and the communication port number and the receiving time of the connection request message are recorded.

3. The device entry method based on IoT unique identifiers according to claim 2, characterized in that, Using the communication handshake timestamps between IoT devices corresponding to adjacent graph nodes as graph edges, an identifier relationship graph for the current batch is constructed in memory, including: for any two IoT devices corresponding to the unique IoT identifiers, calculating the time difference between the first moment when the edge computing node sends a handshake response message to the first IoT device it receives and the second moment when it sends a handshake response message to the adjacent IoT device it receives later. The time difference value is used as the edge attribute value of the graph edge; An undirected graph data structure containing the graph nodes, graph edges, and edge attribute values ​​is created in the memory, and the undirected graph data structure is stored as the identifier relationship graph.

4. The device entry method based on IoT unique identifiers according to claim 3, characterized in that, Traversing the identifier relationship graph and comparing the identifier strings of each graph node, when a conflicting node with the same identifier string is detected, the method includes: using a breadth-first search algorithm to traverse the graph nodes in the identifier relationship graph layer by layer; During the traversal, the hash value of the identifier string of the currently visited graph node is compared with the hash value of the identifier strings of the visited graph nodes. If the hash value of the identifier string of the currently visited graph node is the same as the hash value of the identifier string of any previously visited graph node, then both the currently visited graph node and the previously visited graph node are marked as the conflicting nodes, and the hierarchical position information of the conflicting nodes in the identifier relationship graph is recorded.

5. The device entry method based on IoT unique identifiers according to claim 4, characterized in that, Extract the physical address of the device access port of the IoT device corresponding to the conflicting node and the local clock serial number of the edge computing node, and combine the physical address of the device access port and the local clock serial number according to a preset splicing rule to generate a transitional unique identifier, including: extracting the source address field from the media access control message header of the IoT device corresponding to the conflicting node as the physical address of the device access port; Read the current count value of the high-precision timer inside the edge computing node as the local clock sequence number; The physical address of the device access port is converted to hexadecimal to obtain a first string, and the local clock serial number is converted to binary to obtain a second string; The first string and the second string are concatenated using a preset XOR operator. The concatenated string is then hashed, and the calculated fixed-length hash value is used as the transition unique identifier.

6. The device entry method based on IoT unique identifiers according to claim 5, characterized in that, Establish a mapping index table between the original IoT unique identifier and the transitional unique identifier of the conflicting node, and send an entry request carrying the mapping index table to the central server, including: using the original IoT unique identifier as the index key and the transitional unique identifier as the index value, generating key-value pair records in the local database of the edge computing node; All key-value pair records generated within the same batch are aggregated into the mapping index table; The mapping index table is encapsulated into the request body of a Hypertext Transfer Protocol (HTTP) message, and a concurrent batch identifier field is added to the header of the HTTP message to obtain the database insertion request. The database entry request is sent to the central server via a long-lived Transmission Control Protocol (TCP) connection between the edge computing node and the central server.

7. The device entry method based on IoT unique identifiers according to claim 2, characterized in that, The preset time window and the preset quantity threshold are determined by the following steps: statistically analyzing the distribution data of the number of connection request messages received by the edge computing node on each working day within a historical period; Based on the distribution data of the number of received connection request messages, calculate the average time interval between two consecutive connection request messages; The window length of the preset time window is determined by an integer multiple of the average time interval; Multiply the maximum peak number in the distribution data of the number of received connection request messages by a preset security factor, and round down the product to determine the preset number threshold. The window length and the preset quantity threshold are stored in the configuration file of the edge computing node.

8. The device entry method based on IoT unique identifiers according to claim 3, characterized in that, Storing the undirected graph data structure as the identifier relationship graph includes: allocating a contiguous physical address space in the memory of the edge computing node; In the contiguous physical address space, create an adjacency matrix array and a node pointer array; The graph nodes in the undirected graph data structure are stored in the node pointer array, and the graph edges and their attribute values ​​are stored in the matrix intersection points of the adjacency matrix array corresponding to the graph nodes. Configure a mutex lock for each intersection point of the adjacency matrix array, and acquire the mutex lock for the corresponding intersection point when updating the data in the adjacency matrix array.

9. The device entry method based on IoT unique identifiers according to claim 4, characterized in that, The hash value of the identifier string of the currently visited graph node is compared with the hash value of the identifier string of any visited graph node, including: calling a preset digest algorithm to calculate the hash value of the currently visited graph node and the identifier string of the visited graph node respectively, to obtain the hash value of the current node and the hash value of the historical node. Perform a bitwise XOR operation between the current node hash value and the historical node hash value to obtain the difference feature value; Determine whether the difference feature value is a zero vector; If the difference feature value is not a zero vector, then extract the position number of the non-zero position in the difference feature value, and perform a set intersection operation on the position number and the preset fault-tolerant position set. If the result of the intersection operation of the sets is an empty set, then it is determined that the hash value of the identifier string of the currently visited graph node is different from the hash value of the identifier string of the visited graph nodes.

10. The device entry method based on IoT unique identifiers according to claim 6, characterized in that, After generating key-value pair records in the local database of the edge computing node, the method further includes: obtaining the generation timestamp of the key-value pair records; Create a time-sorted circular queue in the local database; The key-value pair record is combined with the generated timestamp to form a queue element, and the queue element is inserted into the tail of the circular queue; When the length of the circular queue reaches a preset queue capacity threshold, the head element of the circular queue is removed, and the original IoT unique identifier in the head element is read before removal. Send a decommissioning notification message containing the original IoT unique identifier to the log server corresponding to the edge computing node.

Images