A lightweight method and system for sharing data in unmanned aerial vehicle (UAV) swarms.

Abstract

This application relates to a lightweight UAV swarm data sharing method and system in the field of data sharing technology. The method divides the geographical area where the UAV swarm is distributed into multiple units based on the communication range of the UAVs. Each unit has a head UAV, and each head UAV maintains two dynamic cuckoo summaries: DCSO (Data Center State Oscillator) for storing data indexes outside the unit, and DCSL (Data Center State Slave List) for storing all data indexes within the unit. An ingress UAV receives a user request and forwards it to the head UAV of the ingress unit. The head UAV of the ingress unit queries the DCSL according to the request. If the DCSL contains the requested data index, data sharing within the unit is performed; otherwise, the requested data index is mapped to a two-dimensional virtual plane, and data is located and transmitted based on the obtained address. This method improves insertion throughput, reduces response latency, reduces communication overhead, and effectively improves service QoS.

Description

Technical Field

[0001] This application relates to the field of data sharing technology, and in particular to a lightweight method and system for sharing data in a drone swarm. Background Technology

[0002] Air-to-ground networks are considered a core potential architecture for future 6G wireless networks, where drones can be flexibly and easily deployed in the atmosphere. Simultaneously, drones, utilizing technologies such as millimeter wave (MW) and massive MIMO (Multiple-Input Multiple-Output) technology, provide users with better Quality of Service (QoS). Of course, depending on different needs, appropriate types of drones are required to meet various objectives imposed by the desired QoS. Compared to a single drone, drone swarms, through effective collaboration among drones, can significantly expand coverage areas, enhance fault tolerance, and improve mission execution efficiency. For example... Figure 1 As shown, deploying large-scale drone swarms to serve ground users is attractive in many scenarios. For example, drone swarms can respond to emergencies and disasters (such as earthquakes, field searches, and battlefields) by acquiring critical information from disaster areas.

[0003] Data sharing among drones is a fundamental requirement for both users and administrators. Users desire on-demand access to any specific data stored on unknown drones. Data sharing among drones allows users to efficiently search for needed data within the drone network, while improving the service quality of the drone swarm. For administrators, it provides a global overview and up-to-date situational awareness to support more collaborative applications. Complex area monitoring applications, particularly those involving dozens or even more drones operating simultaneously, are common demands on battlefield disaster relief and on-site rescue users and administrators. Therefore, in-depth research into data sharing mechanisms in distributed multi-drone systems is necessary to improve the service quality for both users and administrators.

[0004] The main obstacle to data sharing among drones is the lack of an efficient and reliable data index across all drones. In other words, each user needs to know the data distribution information across all drones. To address this, each drone represents its local data as a set of key-value pairs (KV) and uses a spatially efficient data structure. Storing the KV pairs of all drones on a selected node is straightforward. Currently, upon receiving any request, a drone can direct the request to this centralized index node to locate the requested data. However, this scheme suffers from single-node failure, with the central node becoming a performance bottleneck. Distributed Hash Tables (DHTs) and Multi-hop Delaunay Triangulation (MDTs) are two mainstream distributed indexing schemes for terrestrial networks. However, they cannot be directly applied to drone swarm scenarios. DHTs map drones and data onto a hash ring, locating the requested data based on the hash value. However, a key issue with DHTs is that the drone's hash value is completely independent of its actual location, making it impossible to select a nearby drone based solely on the hash value. MDTs use the location information of all drones as prior knowledge, significantly reducing the number of hops required to retrieve data. However, due to the mobility of drones, this information is difficult to collect. Therefore, drone swarms require a new data sharing mechanism.

[0005] To achieve high-performance data sharing in drone swarms, the following challenges must be addressed. First, the wireless channels between adjacent drones are unstable and affected by drone movement; the actual network topology of a drone swarm is dynamically changing. Typically, drones can move from one unit to another. This fact presents a completely different scenario for data sharing in traditional terrestrial networks. Second, each drone has limited resources, such as communication, bandwidth, and power. Therefore, the data structure used to organize data indexes should be spatially efficient, not support complex computations, and large-scale transmission of data content or indexes is discouraged due to scarce wireless bandwidth. Third, the energy of existing drones is somewhat insufficient. Therefore, frequent data transmission / reception or drone relocation for data sharing is not recommended. Fourth, drones dynamically collect data during mission execution. Therefore, the ability of the swarm representation structure to flexibly expand or shrink to cope with dynamically changing data sizes is crucial. These challenges make data sharing in drone swarms different from traditional wired networks. Summary of the Invention

[0006] Therefore, it is necessary to provide a lightweight method and system for sharing data in drone swarms to address the aforementioned technical problems.

[0007] A lightweight method for sharing data in a drone swarm, the method comprising:

[0008] The geographical area where a large number of drones are distributed is divided into multiple units based on the communication range of the drones; each unit has a head drone, and all drones in the same unit can communicate directly with each other.

[0009] Each head drone maintains two dynamic cuckoo summaries; the two dynamic cuckoo summaries are: DCSO, a dynamic cuckoo summary for data indexes of data items outside the storage unit, and DCSL, a dynamic cuckoo summary for data indexes of all data items within the storage unit.

[0010] The entry drone receives the user's request and forwards it to the head drone of the entry unit; the entry drone is the drone closest to the user, and the entry unit is the unit where the entry drone is located.

[0011] The head of the entry unit - the drone - queries the dynamic cuckoo summary according to the request.

[0012] If the Dynamic Cuckoo Summary (DCSL) includes the requested data index, the user can directly obtain the data from the drone in that unit.

[0013] If the requested data index is not included in the Dynamic Cuckoo Summary DCSL, the requested data index is mapped to a two-dimensional virtual plane, and data is located and transmitted according to the address of the requested data index on the two-dimensional virtual plane.

[0014] In one embodiment, the data index of a data item includes the fingerprint of the data item and the drone ID.

[0015] Each head-to-head drone maintains two dynamic cuckoo summaries, including:

[0016] Each UAV within the cell stores the data index of the data item in the cell header - the UAV's Dynamic Cuckoo Summary DCSL.

[0017] The geographic center and data index of the cell are mapped to a two-dimensional virtual plane to determine the data index of the UAV outside the cell stored in the Dynamic Cuckoo Summary DCSO, and the data index is stored in the Dynamic Cuckoo Summary DCSO of the cell.

[0018] In one embodiment, the geographic center and data index of the cell are mapped to a two-dimensional virtual plane, the data index of the UAV outside the cell is determined and stored in the Dynamic Cuckoo Summary DCSO of the cell, and the data index is stored in the Dynamic Cuckoo Summary DCSO of the cell, including:

[0019] The geographic center of the cell and the data index are mapped onto a two-dimensional virtual plane using the SHA-256 hash function to determine the virtual coordinates of the data index on the two-dimensional virtual plane; the length and width of the two-dimensional virtual plane are both 1; the virtual coordinates are determined by dividing the last 8 bytes of the hash value generated by the SHA-256 hash function of the data index into two parts and normalizing them to decimals.

[0020] Based on the virtual coordinates of the data index and the coordinates of the geographic center of the unit on the two-dimensional virtual plane, the data index of the UAV outside the unit is determined, and the data index is stored in the head of the unit - the dynamic cuckoo summary DCSO of the UAV.

[0021] In one embodiment, if the Dynamic Cuckoo Summary (DCSL) includes the requested data index, the user directly obtains data from the drone of that unit, including:

[0022] If the Dynamic Cuckoo Summary (DCSL) includes the requested data index, the drone storing the requested data index will send the data content corresponding to the request to the input drone, and the input drone will send the data content corresponding to the request to the user.

[0023] In one embodiment, if the requested data index is not included in the Dynamic Cuckoo Summary (DCSL), the requested data index is mapped to a two-dimensional virtual plane, and data location and transmission are performed based on the address of the requested data index on the two-dimensional virtual plane, including:

[0024] If the requested data index is not included in the Dynamic Cuckoo Summary DCSL:

[0025] Map the requested data index onto the two-dimensional virtual plane.

[0026] The entry unit header - drone uses a routing path to forward the requested data index to the remote unit header - drone.

[0027] The remote unit head-drone inspects its dynamic cuckoo summary DCSO to obtain the query results.

[0028] The remote unit head - drone will send the query structure back to the entry unit head - drone.

[0029] If the remote unit head-drone contains the requested data index, the ingress unit head-drone sends the request to the target drone; the target drone sends the data content corresponding to the request to the ingress unit head-drone, the drone in the ingress unit that has the requested data sends the data content to the ingress drone, and the ingress drone sends the data content to the user.

[0030] If the remote unit header - drone does not contain the requested data index, then the drone cluster has not requested the corresponding data.

[0031] In one embodiment, the ingress unit head-drone uses a routing path to forward the requested data index to the remote unit head-drone, including:

[0032] The ingress unit header - UAV uses a HUGG-based greedy routing path to forward the requested data index to the remote unit header - UAV.

[0033] In one embodiment, the dynamic cuckoo digest includes a dynamic cuckoo hash table for storing data indexes of data items, the data indexes including fingerprints of data items and drone identifiers; the dynamic cuckoo hash table includes s linked homogeneous cuckoo digests; each cuckoo digest includes l buckets, each bucket includes b entries, where s, l, and b are integers greater than 0.

[0034] In one embodiment, the method further includes: when a head drone of a unit leaves the unit, the head drone sends its stored data index to a new head drone.

[0035] A lightweight unmanned aerial vehicle (UAV) swarm data sharing system, the system comprising:

[0036] Several units, including several unmanned units; the units are geographical areas where the drone cluster is located, divided according to the communication range of the drones; each unit has a head drone, and all drones within the same unit can communicate directly with each other.

[0037] Each UAV includes two dynamic cuckoo summaries; the two dynamic cuckoo summaries are: DCSO, a dynamic cuckoo summary for data indexes of data items outside the storage unit, and DCSL, a dynamic cuckoo summary for data indexes of all data items within the storage unit.

[0038] When the entry drone receives a user's request, it forwards the request to the head drone of the entry unit. The entry drone is the drone closest to the user, and the entry unit is the unit where the entry drone is located. The head drone of the entry unit queries the Dynamic Cuckoo Summary (DCSL) according to the request. If the DCSL includes the data index of the request, the user directly obtains the data from the drone in that unit. If the DCSL does not include the data index of the request, the data index of the request is mapped to a two-dimensional virtual plane, and the data is located and transmitted according to the address of the data index of the request on the two-dimensional virtual plane.

[0039] The aforementioned lightweight UAV swarm data sharing method and system divides a geographical area with a large number of UAVs into multiple units based on the communication range of the UAVs. Each head UAV maintains two dynamic cuckoo summaries: one for storing data indexes of data items outside the unit, and the other for storing data indexes of all data items within the unit. An entry UAV receives a user's request and forwards it to the head UAV of the entry unit. The head UAV of the entry unit queries the dynamic cuckoo summary (DCSL) according to the request. If the DCSL includes the requested data index, data sharing occurs within the unit; otherwise, the DCSL does not include the requested data index, so the requested data index is mapped to a two-dimensional virtual plane, and data is located and transmitted based on the address of the requested data index on the two-dimensional virtual plane. This method provides a general data sharing service that does not restrict data names and types. This method improves insertion throughput, reduces response latency, reduces communication overhead, and effectively improves the QoS of the service. Attached Figure Description

[0040] Figure 1 An example of a drone swarm operation scenario;

[0041] Figure 2 This is a flowchart illustrating a lightweight drone swarm data sharing method in one embodiment;

[0042] Figure 3 This is a schematic diagram of a lightweight drone swarm data sharing architecture in one embodiment;

[0043] Figure 4 In another embodiment, cell data sharing is provided, where (a) is a greedy routing between cells based on HUCG, and (b) is a proof that the greedy routing can achieve the guarantee.

[0044] Figure 5 Here is an example of a DCS in one embodiment. Detailed Implementation

[0045] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative and not intended to limit the scope of this application.

[0046] In a drone swarm network, each drone stores a large amount of useful data that needs to be shared (such as images, videos, control information, etc.). Figure 1As shown, a large number of drones are distributed within a geographical area, forming a temporary, self-organizing network. The geographical area is divided into multiple units based on the drones' communication range. Each unit selects the drone closest to its geographical center as the leader drone. The main objectives of this lightweight drone swarm data sharing method include: 1) fast data location services, 2) high retrieval accuracy, 3) efficient routing protocols, 4) dynamic capacity expansion, and 5) low implementation overhead. To achieve these objectives, the following two aspects are carefully considered in this invention: First, since retrieving data from the same unit is faster than retrieving data from other units, cached data can be shared locally; therefore, drones should quickly know whether other drones within the same unit have the requested data. Second, data from different units should also be effectively shared. Simultaneously, to save space, the index should only store a subset of drones, rather than every single drone.

[0047] In one embodiment, such as Figure 2 As shown, a lightweight method for sharing data in a drone swarm is provided, which includes the following steps:

[0048] Step 200: Divide the geographical area with a large number of drones into multiple units according to the communication range of the drones; each unit has a head drone, and all drones in the same unit can communicate directly with each other.

[0049] Specifically, such as Figure 1 As shown, a large number of drones are distributed within a geographical area, forming a self-organizing network for temporary flights. The entire drone swarm is based on a software-defined network, characterized by openness, self-formation, self-organization, and energy efficiency. Within any unit, all drones can communicate directly with each other.

[0050] The geographical area is divided into multiple units based on the drone's communication range. Each unit selects the drone closest to its geographical center as the leader drone.

[0051] The geographical region is divided into units considering a UAV network containing K UAVs, where k∈K and k={1,2,...,K}. The UAV flight time is T, which can be divided into N sub-cycles, each denoted by n, where n∈N and N={1,2,...,N}. The UAVs are interconnected via air-to-air (A2A) communication and the 802.11 wireless communication standard carrier-aware multiple access collision (CSMA / CA). For communication between UAVs, a free-space channel model is used. Therefore, at sub-cycle n, the channel power gain from UAVi to UAVj is:

[0052]

[0053] Where ∈ represents the power gain introduced by the amplifier and antenna, (a i，j [n]) -α This represents path loss. At sub-period n, the instantaneous transmission rate characteristic from UAV i to UAV j is:

[0054]

[0055] Where, p i For the transmission power of drone i, σ represents the interference power of all drones except drone i. 2 This is a power of Gaussian noise. In reality, due to the unstable channel conditions between UAVs, the transmission rate cannot exceed a threshold Γ to ensure the correctness of data encoding and demodulation. Therefore, the following constraints also exist:

[0056]

[0057] Assume the drone's transmission power is constant. For equation (3), in order to satisfy this condition... but

[0058] Consider a square cell of size π × π, where each cell contains at least one drone. For example... Figure 1 As shown, the maximum communication distance between two drones in different adjacent units is This is also the maximum communication radius of each drone in our solution. Based on the above expression, to ensure communication between any two drones in adjacent cells, the length π of the square cell should satisfy... Therefore, each drone in each cell can communicate directly with at least four of its neighboring cells based on its geometry.

[0059] Step 202: Each head drone maintains two dynamic cuckoo summaries; the two dynamic cuckoo summaries are: a dynamic cuckoo summary DCSO for data indexes of data items outside the storage unit, and a dynamic cuckoo summary DCSL for data indexes of all data items within the storage unit.

[0060] Specifically, the head-mounted drone is designed with a dynamic cuckoo summary to accurately index all data within the cell.

[0061] On one hand, each drone sends information to its head drone, rather than all other drones in the same unit, which effectively reduces energy and bandwidth consumption. Furthermore, due to limited drone storage space, the head drone only retains a summary of all cached data (the summary refers to the data index), saving space overhead. On the other hand, the DCS can flexibly expand or reduce capacity by adding or deleting cuckoo summaries, while also performing reliable deletion operations. Each head drone maintains two DCSs, DCSL and DCSO, each consisting of several cuckoo summaries. DCSL records the data index within the unit to achieve data sharing within the unit, while DCSO stores the data index outside the unit to achieve data sharing between units. In each DCS, the data index is stored in either of two candidate buckets. In this data structure, querying and deleting the data index requires only constant time consumption.

[0062] The core component of DCS is a Dynamic Cuckoo Hash Table (DCHT). Each entry in the Dynamic DCHT (each entry refers to each record in the Dynamic Cuckoo Hash Table) is composed of a fingerprint of a cached data item and a drone identifier (ID).

[0063] Using the MD5 hash of the data as the key and the MAC address of the drone as the value, and its KV pairs as the index, each data item is localized.

[0064] To reduce space usage, each head-drone only has a partial data index, while all head-drones collaboratively maintain a global index for all data items.

[0065] Step 204: The entry drone receives the user's request and forwards it to the head of the entry unit - drone; the entry drone is the drone closest to the user, and the entry unit is the unit where the entry drone is located.

[0066] Specifically, Figure 3 This demonstrates a two-stage workflow for data sharing. The intra-cell stage addresses how to share data within a single cell. Conversely, if the requested data cannot be found within the entry cell, the inter-cell stage is triggered to help locate the requested data.

[0067] Step 206: Header of the entry unit - The drone queries the dynamic cuckoo summary based on the request.

[0068] Step 208: If the Dynamic Cuckoo Summary DCSL includes the requested data index, the user obtains the data directly from the drone in that unit.

[0069] Specifically, for a user's request, the user first sends it to the local head unit – the drone (the unit where the nearest drone to the user is located). If the corresponding DCS indicates that the drone in that unit stores the data requested by the user, the user can directly retrieve the data from the drone in that unit. This process is called intra-unit sharing; otherwise, the requested data index is not stored locally, thus triggering the inter-unit sharing step and helping to locate the requested data.

[0070] Step 210: If the requested data index is not included in the Dynamic Cuckoo Summary DCSL, then map the requested data index to a two-dimensional virtual plane, and locate and transmit the data according to the address of the requested data index on the two-dimensional virtual plane.

[0071] Specifically, a two-dimensional virtual plane mapping strategy is used to determine the storage unit for the requested data index. All data indexes in the drone swarm, along with the geographic coordinates of the unit centers, are mapped onto a two-dimensional virtual plane. Then, a data index is assigned to the nearest unit on the virtual plane. Using this design, querying the unit containing the requested data index becomes very straightforward. After knowing which unit to access, the next question is how to forward the request from the entry unit to the target unit (the unit where the index is stored). To this end, a head-drone communication graph is further constructed, explicitly representing the head-drone connectivity. With the aid of this framework, the flight path from the entry head to the target head (i.e., the path from the entry unit to the target unit) can be easily derived using only the positional information of adjacent drone heads. Furthermore, for load balancing and performance considerations, multiple virtual coordinates are allowed for each data point. Since the geographic distance between any two unit centers remains within the virtual plane, the nearest unit can be selected to respond to the request.

[0072] The data index and head-UAV mapping are mapped onto a two-dimensional virtual plane. Based on this virtual plane, a head-UAV communication map is formed according to the communication range of each head, enabling data positioning and transmission.

[0073] The aforementioned lightweight UAV swarm data sharing method divides a geographical area with a large number of UAVs into multiple units based on the communication range of the UAVs. Each head UAV maintains two dynamic cuckoo summaries: one for storing data indexes of data items outside the unit, and the other for storing data indexes of all data items within the unit. An entry UAV receives a user's request and forwards it to the head UAV of the entry unit. The head UAV of the entry unit queries the dynamic cuckoo summary (DCSL) according to the request. If the DCSL includes the requested data index, data sharing occurs within the unit; otherwise, the DCSL does not include the requested data index, so the requested data index is mapped to a two-dimensional virtual plane, and data is located and transmitted based on the address of the requested data index on the two-dimensional virtual plane. This method provides a general data sharing service without restrictions on data names and types. This method improves insertion throughput, reduces response latency, reduces communication overhead, and effectively improves the QoS of the service.

[0074] In one embodiment, the data index of the data item includes the fingerprint of the data item and the drone ID; step 202 includes: each drone in the unit stores the data index of the data item in the head of the unit - the dynamic cuckoo summary DCSL of the drone; mapping the geographic center of the unit and the data index to a two-dimensional virtual plane, determining the data index of the drone outside the unit stored in the dynamic cuckoo summary DCSO, and storing the data index in the dynamic cuckoo summary DCSO of the unit.

[0075] In one embodiment, mapping the geographic center and data index of a unit to a two-dimensional virtual plane, determining the data index of a UAV outside the unit stored in the Dynamic Cuckoo Summary DCSO, and storing the data index in the Dynamic Cuckoo Summary DCSO of the unit includes: mapping the geographic center and data index of the unit to a two-dimensional virtual plane using a SHA-256 hash function, determining the virtual coordinates of the data index on the two-dimensional virtual plane; the length and width of the two-dimensional virtual plane are both 1; the virtual coordinates are determined by dividing the last 8 bytes of the hash value generated by the SHA-256 hash function of the data index into two parts and normalizing them to decimals; determining the data index of the UAV outside the unit based on the virtual coordinates of the data index and the coordinates of the geographic center of the unit on the two-dimensional virtual plane, and storing the data index in the head of the unit - the Dynamic Cuckoo Summary DCSO of the UAV.

[0076] Specifically, which data indexes should the DCSO store? To address this issue, a proposed approach is to map the geographic center of a cell and its data indexes onto a two-dimensional virtual plane to enable real-time, accurate cross-cell data location requests. Each data index can have multiple copies for better performance and load balancing. Specifically, the virtual plane has a length and width of 1. The geographic coordinates of the cell center are normalized and mapped onto the virtual plane. This ensures that the distance between any pair of cell centers on the virtual plane is exactly the same as the distance between cell centers on the geographic plane. This is crucial for selecting the nearest cell for a request. For each data index, it is mapped onto the virtual plane using a SHA-256 hash function. Its coordinates on the virtual plane are determined by splitting the last 8 bytes of the generated hash value into two parts and normalizing them to a decimal in [0,1]. Subsequently, any data index will be stored by the head of the cell containing the virtual coordinates – the drone. With this design, it is possible to directly deduce which cell head is responsible for the requested data index.

[0077] In one embodiment, step 208 includes: if the Dynamic Cuckoo Summary DCSL includes the requested data index, the drone storing the requested data index sends the data content corresponding to the request to the input drone, and the input drone sends the data content corresponding to the request to the user.

[0078] Specifically, regarding data sharing within the drone unit, see... Figure 3 (2-4, 13). Unmanned aerial vehicle (UAV) networks are typically highly dynamic datasets, with items frequently connecting and disconnecting. To achieve rapid data location services within cells, a UAV swarm topology graph was constructed, and a dynamic cuckoo summarization mechanism was designed to address the needs of highly dynamic datasets.

[0079] In one embodiment, step 210 includes: if the Dynamic Cuckoo Summary (DCSL) does not contain the requested data index: the requested data index is mapped onto a two-dimensional virtual plane; the ingress unit head-UAV forwards the requested data index to the remote unit head-UAV using a routing path; the remote unit head-UAV checks its Dynamic Cuckoo Summary (DCSO) to obtain the query result; the remote unit head-UAV returns the query structure to the ingress unit head-UAV; if the remote unit head-UAV contains the requested data index, the ingress unit head-UAV sends a request to the target UAV; the target UAV sends the requested data content to the ingress unit head-UAV, the UAV in the ingress unit that has the requested data sends the data content to the ingress UAV, and the ingress UAV sends the data content to the user; if the remote unit head-UAV does not contain the requested data index, the UAV cluster does not have the requested data.

[0080] Specifically, regarding data sharing between drone units, see... Figure 3 (5-12). In UAV swarm networks, these distributed UAVs store a large amount of dynamic data. To achieve rapid data location services across units, we designed a HUCG-based scheme to reduce the need to find underlying hops and handle heavy workloads in low-implementation scenarios.

[0081] (1) Determine coordinates

[0082] Because each head-drone maintains a two-dimensional virtual plane In the head - drones and virtual planes An index is assigned to all shared data items with virtual coordinates. Due to the maneuverability of the drone, the head-drone coordinates are replaced by the center of the cell. Therefore, the drone swarm has M cells. Therefore, the center coordinates of the element, These are the coordinates of the head-drone m in the virtual plane. To facilitate data indexing and querying, the coordinates of the head-drone range in each dimension are restricted to 0 to 1. Therefore, the virtual coordinates of each head-drone are rewritten as follows:

[0083] The virtual coordinates of the data index are obtained by calculating the hash value. This invention uses the SHA-256 hash function to output a 32-byte binary value, converting only the last 8 bytes into two 4-byte binary numbers, g and z. Due to its ease of computation and strong collision resistance, SHA-256 is the optimal choice for calculating data index coordinates. This allows the data index and the head-up drone to be positioned on a virtual plane. Within the same cell, the coordinates of the data index are also restricted to [0,1]. Therefore, the coordinates of the data index in the virtual plane are represented as... Note that the coordinates of any data index d are represented by hash values ​​and stored in the virtual plane. The head of the drone is closest to coordinate d.

[0084] (2) Forwarding data index

[0085] In the HUCG-based scheme, each head-drone greedily forwards the data index to the head-drone closest to the data index position in the virtual plane.

[0086] HUCG construction addresses the challenge of constructing a dynamic topology for drone swarms when drones operate within a cluster. These drones may continuously change positions during missions, potentially leading to link breakdowns when two drones go out of communication range. To ensure delivery, HUCG is constructed by connecting the head-drone coordinates on a virtual plane. That is, given a set of head-drone pairs and their virtual coordinates H...m Generate an edge, while the two heads of the drone can be based on... Mutual communication. Specifically, if It will construct an edge where H p and H q They are called neighbors.

[0087] Furthermore, based on HUCG, data indexes are greedily forwarded to the head-UAV closest to the data location in the virtual plane. This assumes the head-UAV has its published data index coordinates on the virtual plane. The data index is mapped to point H. dst Therefore, the data index will be stored in the head-drone H. m In, where {|H u -H dst |>|H m -H dst |},m=1,...,M,u≠m。

[0088] To reduce implementation overhead, these head-drones perform greedy forwarding. That is, without requiring additional information, each head-drone forwards only one data index based on the coordinates and data index of its neighbors. More precisely, a head-drone will forward a data index to its neighboring head-drone with the closest data index coordinates on the virtual plane. For example... Figure 4 As shown in (a), the data index d1 requested in C1 has coordinates H. dst The specific process is as follows: Head-Drone H1 first obtains the closest H among all neighbors. dst The head-drone H6 is then forwarded to the head-drone H6; then, the head-drone H6 finds the closest H in the entire virtual plane. dst Head of the drone H 12 Therefore, data index d1 is stored in H. 12 Furthermore, based on these connections in HUCG, the head-UAV inserts forwarding entries into itself, where each forwarding entry represents the coordinates of a neighbor. The HUCG-based scheme can achieve... Data is forwarded by stacking hops. However, the Greedy Routing (GR) algorithm can get stuck in a local minimum. We need to prove that the GR algorithm guarantees delivery.

[0089] (3) Searching for data indexes

[0090] When publishing a data index, it is assigned to the head-mounted drone closest to the data index location on the virtual plane. The head-mounted drone then stores the data index and responds to all requests for data. Similar to forwarding the data index, the lookup process is as follows: Figure 4As shown in (a), data index d1 is stored in the head-drone H 12 In the middle. When a drone in C8 needs to find d1, the search request is first sent to the head drone H8. The head drone H8 compares the coordinates of all its neighbors in the virtual plane with H. dst The distance is compared, and the request is sent to the head-drone H. 11 The latter is the closest to H among all the neighbors. dst The location is closest. Then, the head-drone H 11 Greedily forward requests to the closest node to H in the entire virtual plane. dst Head of position - drone H 12 Thus, by inspecting the head of the drone H 12 The DCSO can be used to find data index d1.

[0091] Data index copies. Multiple index copies can exist in a drone network, improving its fault tolerance and load balancing capabilities, thereby enhancing QoS. For example, a drone network maintains multiple index copies for each shared data item. It only needs to concatenate a sequence number with the data index of each index copy. Then, based on the updated index identifier, its position in the virtual plane is obtained. Depending on their position, these index copies will be stored in different units in response to drone requests. In this scenario, when the head drone receives a lookup request, it discovers multiple data copies and further forwards the lookup request to multiple relevant drones. The drones will then provide the request with the fastest response.

[0092] (4) Transmit request data

[0093] After determining which drone possesses the required data, that drone needs to transmit the data to other drones. Since the transmission time is on the order of milliseconds, the distance the drones travel is negligible. According to HUCG's method, drones acquire all their neighbors by communicating with the head drone in the same cell. Within a cell, the drone that first receives data acts as a transmitter drone and continues transmitting data while broadcasting an ACK to other drones in the same cell. When others receive the ACK, they discard data that is no longer being transmitted. For example, as... Figure 4As shown in (a), UAV1 needs to transmit data d1 to UAV5. UAV1 uses the GR algorithm to obtain the next hop based on HUCG, therefore, UAV1 transmits the data to C2. UAV2 in unit C2 first receives the data and sends an ACK back to C2. After receiving the ACK from UAV2, UAV3 and UAV4 terminate their routing process and release the occupied wireless channel. Therefore, UAV2, as a transmission UAV, further forwards the data to UAV5. To implement the designed GR algorithm, the following settings are required in practical applications:

[0094] 1) Each drone should be able to identify other drones within the same unit. This allows drones to check if data was sent by a drone from the same unit. Therefore, the number of units needs to be determined before a drone network forms a swarm. The encoded packet should contain the transmitter drone's ID and information about the original data packet. This information enables the receiver drone to check if it received data from the same unit.

[0095] 2) Through the communication module, the drone can communicate with other drones and ground control station administrators via SDN technology. Two main communication technologies are used: WiFi and Long Term Evolution (LTE). WiFi has a range of approximately 100 meters, while LTE offers fast and robust communication, suitable for long-range applications. Relevant information will be included in the header of the 802.11 physical frame.

[0096] (5) Path reliability analysis of greedy routing

[0097] Based on the rigorous theoretical foundation in existing literature, it can be proven that the GR algorithm in HUCG has the property of guaranteeing delivery. Figure 4 The HUCG is a 16-cell graph, where the HUCG conforms to the definition of a Voronoi diagram (VD). The GR algorithm always considers H... cur The data is forwarded to the adjacent gdy(H) cur ), to minimize dist(gdy(H cur H dst ), where dist(p,q) represents the Euclidean distance between p and q. There are two cases in which the GR algorithm cannot forward data to its destination: 1) the data is stuck moving back and forth between two points, or 2) the data is stuck in a loop between three or more points.

[0098] This embodiment demonstrates that each vertex H1 has a vertex that is strictly closer to H than H1. des The neighbor. (Reference) Figure 4 In (b), at each routing step, the data packet is closer to H. des It takes at most n steps to reach H. desConsider VD (dashed line), and let e be the intersection of VD and the directed line segment (H1, H2). des The first edge that intersects. Note that e lies on the boundary of two Voronoi cells, one representing H1 and the other representing another vertex H2. The support line of e divides the plane into open half-planes. And τ = {p:dist(p,H2) < dist(p,H1)}. Simultaneously, by choosing e, H... dst ∈b, i.e., dist(H2,H) dst ) < dist(H1,H dst ).

[0099] In HUCG, there exists a neighbor H6, dist(H6, H dst ) < dist(H2,H dst Therefore, HUCG has a better routing process than Voronoi graph.

[0100] (6) Complexity Analysis

[0101] For a HUCG-based scheme, there exists a point θ in HUCG, where the two farthest points are p and q, with coordinates p = (x1, y1) and q = (x2, y2) respectively. The parameter dist(p, q) represents the Euclidean distance between p and q. The forwarding hop count from p to q in GR can be expressed as:

[0102]

[0103] Where β = |x2 - x1|, γ = |y2 - y1|, since The average number of forwarding coverage hops between drones is

[0104] In one embodiment, the ingress unit head-drone uses a routing path to forward the requested data index to the remote unit head-drone, including: the ingress unit head-drone uses a HUGG-based greedy routing path to forward the requested data index to the remote unit head-drone.

[0105] In one embodiment, the dynamic cuckoo digest includes a dynamic cuckoo hash table for storing data indexes of data items, the data indexes including fingerprints and drone identifiers of the data items; the dynamic cuckoo hash table includes s linked homogeneous cuckoo digests; each cuckoo digest includes l buckets, each bucket includes b entries, where s, l, and b are integers greater than 0.

[0106] Specifically, to achieve data sharing among drone swarms, this invention designs a sharing protocol called Dynamic Cuckoo Summary (DCS). DCS consists of s connected homogeneous cuckoo summary (CS) groups CS1, CS2..., CS... s Composition, of which CS k This represents the k-th Rhododendron Summary (CS) in the DCS. Each CS... k Composed of l buckets B k (0), B k (1), ..., B k Composed of (l-1), each bucket has b entries, where l and b represent the number of buckets in each CS and the number of entries in each bucket, respectively. Initially, a DCS has a single CS, and its capacity is expanded by attaching new CSs. We... Figure 5 An example of a DCS is given, showing a (2,4)-cuckoo hash table where each entry has two candidate buckets h1 and h2, and each bucket has 4 slots. Therefore, an entry can be stored in one of the 8 slots. To reduce the drone's memory and energy consumption, this invention employs a partially critical cuckoo hash scheme. Specifically, the DCS uses only a few bits to store the fingerprint of the cached data, rather than storing the complete identifier of the cached data.

[0107] To quickly identify which drone cached the requested data, this invention cleverly links the fingerprint and ID of the cached data item. In DCHT, an entry is a basic storage unit consisting of two elements: the fingerprint of the cached data item and its drone ID (e.g., ...). Figure 5 As shown (see diagram), this is the <fingerprint, ID>. The ID is the identifier for the corresponding drone. Specifically, the ID is log2(e1+e2) bits in size, where e1 is the maximum number of units, and e2 represents the maximum number of drones in a unit. While the ID may increase memory consumption, it effectively improves lookup throughput. Under DCS, when the head-drone receives a request, it first looks up the DCSL to check if the data is cached in the unit. If the fingerprint matches successfully, the head-drone determines the drone that cached the requested data. Here, each drone is considered a set, and the cached data in the drone is treated as an element in that set. In this process, the data checking process is called multi-set membership filtering and lookup. The following section details how DCS performs insert, lookup, and delete operations.

[0108] 1) Cached Data Items: Assume each data item has a unique data identifier. In practice, the drone needs to send insertion information to the corresponding header in two cases: 1) one drone caches one data item, 2) the drone flies into the unit. It's worth noting that the fingerprint is significantly shorter than the data item identifier, which effectively reduces memory requirements. When the DCS performs an insertion operation, an entry <fingerprint, ID> is created, representing the data cached by one of the drones. Based on dynamic cuckoo hashing, each item has two candidate buckets, h1 and h2. Typically, more hash functions lead to more memory accesses and may even increase lookup latency.

[0109] like Figure 5 The diagram illustrates an example of inserting a new item `d` into a hash table of three building blocks, each with four buckets and four entries. Clearly, the first building block is already full. The pointer `curCS` points to the second building block. Fingerprint ξ d By hash function ξ d =h0(d) is calculated, and the two candidate buckets (the 0th and 2nd buckets) are calculated by equation (5). Fingerprint ξ d The entry will be inserted into curCS (e.g., the second building block). The insertion process is as follows: If both candidate buckets are fully occupied, an entry p is randomly selected and repositioned to occupy entry q. The victim q is reassigned to its alternative candidate bucket 2. Reassignment ends when all entries find their own bucket or the number of reassignments reaches the predefined maximum number of repositions. If an insertion failure occurs (e.g., the number of repositions in the second building block reaches the predefined maximum number of repositions), the kicked-out fingerprint will be inserted one by one into the following building blocks ( Figure 5 The third bucket in the list), until the DCS is successfully inserted. The DCS will create a new DCS, and if there is no active DCS, it will be appended to the linked list. In particular, the addresses of the two candidate buckets storing the ξd fingerprint are calculated as follows:

[0110]

[0111] For any data item d, the XOR operation in equation (5) ensures an important property: the spare bucket h2 can be directly calculated from the current bucket index h1. In this way, the re-insertion operation only uses information from the hash table and does not require retrieving the original item d. The time complexity of inserting the data index is O(bs).

[0112] 2) Response to Requests: For DCS, the lookup process is straightforward. When the head-UAV receives a request to query data item d, the head-UAV first calculates the fingerprint ξ. d and for the host ξ dThe addresses of candidate buckets h1(d) and h2(d) are then determined by the DCS for each CS. th and h2(d) th The fingerprints stored in the bucket are used for ξ d Check. If a match is found, the DCS returns the corresponding drone ID; otherwise, if d does not belong to the cell, it returns "false". Furthermore, the same fingerprint can match multiple drone IDs, and the request will be forwarded to all matching drones simultaneously. If there are multiple copies of data in this cell, the requester will receive the data from the drone that responds to the request the fastest. The time complexity of a DCS query operation is O(bs).

[0113] 3) Deleting Data Items: When the drone deletes some useless data, or when the drone flies out of the unit, the head-drone needs to delete the corresponding entry from the DCSL. Specifically, to delete item d, the DCS first locates the fingerprint ξ in the candidate bucket. d When the corresponding fingerprint is found d If the match <fingerprint, ID> is not found in the data structure, the corresponding entry will be deleted from the DCS. Otherwise, "false" will be returned. If d is not an item in the cell, the deletion will fail. The time complexity of deleting a data item is O(bs).

[0114] In one embodiment, the method further includes: when a head drone of a unit leaves the unit, the head drone sends its stored data index to a new head drone.

[0115] In a specific embodiment, such as Figure 2 As shown, the two-stage workflow for data sharing is as follows: the first four steps explain the details of intra-cell queries, while the other steps show the details of inter-cell queries.

[0116] Step 1: The user sends a request to the nearest drone. This drone is referred to as the incoming drone, and this unit is referred to as the incoming unit.

[0117] Step 2: Upon receiving the request, the drone forwards the request to the entrance unit head of the community - the drone.

[0118] Step 3: Entry Unit Head - The UAV queries its data fingerprint based on its DCSL.

[0119] Step 4: The query results are obtained by checking the two candidate buckets. If DCSL has the requested index, proceed to step 13; otherwise, proceed to step 5.

[0120] Step 5: Map the requested data fingerprint to the virtual plane.

[0121] Step 6: Entry Unit Header - The UAV determines which remote unit head is responsible for the requested data index.

[0122] Step 7: The entry unit header forwards the request to the remote unit header - the drone - using the routing path.

[0123] Step 8: Remote Unit Head - The drone checks its DCSO.

[0124] Step 9: Remote Unit Head - The UAV obtains the query results from its DCSO.

[0125] Step 10: Remote Unit Header - The drone sends the query results back to the entry unit head - the drone.

[0126] Step 11: If the remote unit head-drone has the index of the requested data, the ingress unit head-drone sends the request to the target drone; otherwise, the drone cluster does not have the data.

[0127] Step 12: The target drone sends the data content to the entry unit head - drone.

[0128] Step 13: The drone with the requested data sends the data content to the ingress drone.

[0129] Step 14: The entry drone sends the data content to the user.

[0130] It should be understood that, although Figure 2 The steps in the flowchart are shown sequentially as indicated by the arrows, but these steps are not necessarily executed in the order indicated by the arrows. Unless explicitly stated in this invention, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Furthermore, Figure 2 At least some of the steps in the process may include multiple sub-steps or multiple stages. These sub-steps or stages are not necessarily completed at the same time, but can be executed at different times. The execution order of these sub-steps or stages is not necessarily sequential, but can be executed in turn or alternately with other steps or at least some of the sub-steps or stages of other steps.

[0131] Data sharing within a drone swarm is a fundamental requirement for both users and administrators. This invention proposes a framework for achieving efficient data sharing among drones in a drone swarm. Specifically, this architecture implements intra-cell data sharing based on a Data Capability System (DCS) and inter-cell data sharing based on a virtual plane. For a user request, if the corresponding DCS indicates that the requested data is stored by a drone within that cell, it is first directed to the local head drone. The user can then directly collect data from that drone. Otherwise, the requested data index is mapped onto the virtual plane to determine which cell is responsible for that data index. A method called HUGG is then used to derive a reasonable path for forwarding and responding to the request. Extensive experiments have demonstrated the advantages of this data sharing framework, including low false positives, higher insertion throughput, lower response latency, lower implementation overhead, and appropriate load balancing, while also supporting multiple replicas and dynamic datasets.

[0132] In one embodiment, a lightweight drone swarm data sharing system is provided, comprising: several units, each containing several drones; each unit is a geographical area where the drone swarm is located, divided according to the communication range of the drones; each unit has a leader drone, and all drones within the same unit can communicate directly with each other.

[0133] Each UAV includes two dynamic cuckoo summaries; the two dynamic cuckoo summaries are: DCSO, a dynamic cuckoo summary for data indexes of data items outside the storage unit, and DCSL, a dynamic cuckoo summary for data indexes of all data items within the storage unit.

[0134] When the ingress drone receives a user's request, it forwards the request to the head drone of the ingress unit. The ingress drone is the drone closest to the user, and the ingress unit is the unit where the ingress drone is located. The head drone of the ingress unit queries the Dynamic Cuckoo Summary (DCSL) according to the request. If the DCSL contains the requested data index, the user directly obtains the data from the drone in that unit. If the DCSL does not contain the requested data index, the requested data index is mapped to a two-dimensional virtual plane, and the data is located and transmitted according to the address of the requested data index on the two-dimensional virtual plane.

[0135] The technical features of the above embodiments can be combined in any way. For the sake of brevity, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0136] The embodiments described above are merely illustrative of several implementation methods of this application, and while the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the invention patent. It should be noted that those skilled in the art can make various modifications and improvements without departing from the concept of this application, and these all fall within the protection scope of this application. Therefore, the protection scope of this patent application should be determined by the appended claims.

Claims

1. A lightweight method for sharing data in a drone swarm, characterized in that, The method includes: The geographical area where the drone swarm is located is divided into multiple units based on the drone's communication range; each unit has a head drone, and all drones within the same unit can communicate directly with each other. Each head drone maintains two dynamic cuckoo summaries; the two dynamic cuckoo summaries are: DCSO, a dynamic cuckoo summary for data indexes of data items outside the storage unit, and DCSL, a dynamic cuckoo summary for data indexes of all data items within the storage unit. The entry drone receives the user's request and forwards it to the head drone of the entry unit; the entry drone is the drone closest to the user, and the entry unit is the unit where the entry drone is located; The head of the entry unit—the drone—queries in the dynamic cuckoo summary according to the request; If the Dynamic Cuckoo Summary DCSL includes the requested data index, the user can directly obtain the data from the drone in that unit. If the requested data index is not included in the Dynamic Cuckoo Summary DCSL, the requested data index is mapped to a two-dimensional virtual plane, and data is located and transmitted according to the address of the requested data index on the two-dimensional virtual plane. The specific steps include: if the requested data index is not included in the Dynamic Cuckoo Summary DCSL, all data indexes in the UAV cluster and the geographical coordinates of the unit center are mapped to a two-dimensional virtual plane, and a data index is assigned to the nearest unit on the two-dimensional virtual plane; based on the two-dimensional virtual plane, a head-UAV communication graph is constructed according to the communication range of each head-UAV; the head-UAV of the entry unit forwards the requested data index to the remote unit head-UAV using a greedy routing path based on the head-UAV communication graph.

2. The method according to claim 1, characterized in that, The data index for a data item includes the data item's fingerprint and the drone ID; Each head-to-head drone maintains two dynamic cuckoo summaries, including: Each UAV within the cell stores the data index of the data item in the header of this cell - the UAV's Dynamic Cuckoo Summary DCSL; The geographic center and data index of the cell are mapped to a two-dimensional virtual plane to determine the data index of the UAV outside the cell stored in the Dynamic Cuckoo Summary DCSO, and the data index is stored in the Dynamic Cuckoo Summary DCSO of the cell.

3. The method according to claim 2, characterized in that, Mapping the geographic center and data index of a cell to a two-dimensional virtual plane, determining the data index of UAVs outside the cell stored in the Dynamic Cuckoo Summary DCSO, and storing this data index in the Dynamic Cuckoo Summary DCSO of the cell, including: The geographic center of the cell and the data index are mapped onto a two-dimensional virtual plane using the SHA-256 hash function to determine the virtual coordinates of the data index on the two-dimensional virtual plane; the length and width of the two-dimensional virtual plane are both 1; the virtual coordinates are determined by dividing the last 8 bytes of the hash value generated by the SHA-256 hash function of the data index into two parts and normalizing them to decimals; Based on the virtual coordinates of the data index and the coordinates of the geographic center of the unit on the two-dimensional virtual plane, the data index of the UAV outside the unit is determined, and the data index is stored in the head of the unit - the dynamic cuckoo summary DCSO of the UAV.

4. The method according to claim 1, characterized in that, If the Dynamic Cuckoo Summary (DCSL) includes the requested data index, the user directly obtains data from the drone in that unit, including: If the Dynamic Cuckoo Summary (DCSL) includes the requested data index, the drone storing the requested data index will send the data content corresponding to the request to the input drone, and the input drone will send the data content corresponding to the request to the user.

5. The method according to claim 1, characterized in that, If the requested data index is not included in the Dynamic Cuckoo Summary DCSL, then the requested data index is mapped to a two-dimensional virtual plane, and data location and transmission are performed based on the address of the requested data index on the two-dimensional virtual plane, including: If the requested data index is not included in the Dynamic Cuckoo Summary DCSL: Map the requested data index onto the two-dimensional virtual plane; The entry unit header - drone uses a routing path to forward the requested data index to the remote unit header - drone; The remote unit head-drone inspects its dynamic cuckoo summary DCSO to obtain query results; The remote unit head-drone will send the query structure back to the ingress unit head-drone; If the remote unit head-drone contains the requested data index, the ingress unit head-drone sends the request to the target drone; the target drone sends the data content corresponding to the request to the ingress unit head-drone, the drone in the ingress unit that has the requested data sends the data content to the ingress drone, and the ingress drone sends the data content to the user. If the remote unit header - drone does not contain the requested data index, then the drone cluster has not requested the corresponding data.

6. The method according to any one of claims 1-5, characterized in that, The ingress unit header - drone uses a routing path to forward the requested data index to the remote unit header - drone, including: The ingress unit header - UAV uses a HUGG-based greedy routing path to forward the requested data index to the remote unit header - UAV.

7. The method according to any one of claims 1-5, characterized in that, The dynamic cuckoo summary includes a dynamic cuckoo hash table, which stores data indexes for data items. These data indexes include the fingerprint and drone identifier of the data item. The dynamic cuckoo hash table includes... s A series of homogeneous cuckoo summaries linked together; each cuckoo summary includes... l Each bucket contains [number] buckets. b There are 4 entries, where s, l, and b are integers greater than 0.

8. The method according to any one of claims 1-5, characterized in that, The method further includes: when a head drone of a unit leaves the unit, the head drone sends its stored data index to a new head drone.

9. A lightweight unmanned aerial vehicle (UAV) swarm data sharing system, characterized in that, The system includes: several units, each containing several unmanned drones; each unit is a geographical area divided according to the communication range of the drones; each unit has a head drone, and all drones within the same unit can communicate directly with each other; Each UAV includes two dynamic cuckoo summaries; the two dynamic cuckoo summaries are: DCSO, a dynamic cuckoo summary for data indexes of data items outside the storage unit, and DCSL, a dynamic cuckoo summary for data indexes of all data items within the storage unit. When the entry drone receives a user's request, it forwards the request to the head drone of the entry unit. The entry drone is the drone closest to the user, and the entry unit is the unit where the entry drone is located. The head drone of the entry unit queries the Dynamic Cuckoo Summary (DCSL) according to the request. If the DCSL includes the requested data index, the user directly obtains the data from the drone in that unit. If the DCSL does not include the requested data index, the requested data index is mapped to a two-dimensional virtual plane, and data location and transmission are performed based on the address of the requested data index on the two-dimensional virtual plane. Specifically, if the DCSL does not include the requested data index... If the requested data index is not included in the Dynamic Cuckoo Summary (DCSL), then all data indexes in the UAV cluster and the geographic coordinates of the unit centers are mapped onto a two-dimensional virtual plane, and a data index is assigned to the nearest unit on the two-dimensional virtual plane. Based on the two-dimensional virtual plane, a head-UAV communication graph is constructed according to the communication range of each head-UAV. The head-UAV of the entry unit forwards the requested data index to the remote unit head-UAV using a greedy routing path based on the head-UAV communication graph.

Images