Node Load and Location-Based Clustering Protocol for Underwater Acoustic Sensor Networks

Abstract

Clustering protocols for underwater acoustic sensor networks (UASNs) have gained widespread attention due to their importance in reducing network complexity. Congestion occurs when the intra-cluster load is greater than the upper limit of the intra-cluster information transmission capacity, which leads to a dramatic deterioration of network performance despite the reduction of network complexity. To avoid congestion, we propose a node load and location-based clustering protocol for UASNs (LLCP). First, a node load and location-based optimization mechanism is proposed. The number of cluster members is optimized based on node load and location to maximize the number of cluster members while avoiding congestion. Then, a node degree and location-based cluster member selection mechanism is proposed to select the optimal cluster members. Finally, a priority-based clustering mechanism is proposed. The node clustering order is adjusted based on the clustering priority to maximize the reduction of network complexity by increasing the average number of cluster members. Simulation results show that our proposed LLCP minimizes the network complexity while avoiding congestion.

1. Introduction

Underwater acoustic sensor networks (UASNs) are experiencing rapid growth, driven by the urgent need for large-scale marine scientific and industrial applications, e.g., marine environmental information collection, marine biological information monitoring, assisted navigation, marine mineral resources exploration, etc. [1,2,3,4,5,6].

Acoustic wave is considered to be the signal carrier with optimal performance in an underwater environment due to the small attenuation characteristics [7,8]. However, the limited bandwidth available for communication in underwater environment leads to a low upper limit of information transmission capacity. In complex UASNs, frequent channel access and large amounts of information transmission need to take up a large amount of channel resources, resulting in a sharp decline in network performance. Clustering protocols help mitigate this issue by electing cluster heads to manage channel access and information transmission for cluster members [9,10]. This approach reduces the frequency of channel access and the amounts of information transmission, thereby decreasing network complexity and enhancing network performance.

The number of cluster members has a significant impact on the network performance [11,12]. Node load and location have a significant impact on the optimal number of cluster members. The node load and the number of cluster members together determine the intra-cluster load, while the node location affects the upper limit of intra-cluster information transmission capacity. Too many nodes joining the same cluster will not only lead to an increase in intra-cluster complexity, but also lead to congestion or even network collapse when the intra-cluster load is greater than the upper limit of the intra-cluster information transmission capacity. Too few nodes joining the same cluster will in turn lead to too many clusters, resulting in still higher network complexity. Therefore, minimizing the cluster number while avoiding congestion can greatly improve network performance.

Due to the crucial role of clustering protocols in network performance, researchers have proposed numerous clustering protocols to enhance network performance [13,14]. The existing clustering protocols primarily consider factors such as distance, node density, and residual energy for clustering. By adjusting communication distances, nodes at varying distances from the cluster head can be included in the cluster, thereby balancing energy consumption by adjusting the energy consumption of nodes at different locations. Node density is managed by adjusting the cluster’s coverage area based on energy constraints, reducing the coverage area in high-density regions to lower energy consumption. Residual energy is used to achieve energy balance, thereby extending the network lifetime. However, existing clustering protocols still struggle to effectively address the impacts of node load and location on network performance.

Aiming at the issues of network congestion as well as high complexity due to node load and location, we propose a node load and location-based clustering protocol for UASNs (LLCP). The number of cluster members is optimized based on node load and location to minimize the network complexity without congestion.

The main contributions of this paper are as follows:

(1)

We propose a node load and location-based cluster member number optimization mechanism. Load determines the length of time slots required for channel access, while location affects the efficiency of channel access. By analyzing the impact of cluster member numbers on congestion based on node load and location information, we derive constraints on the maximum cluster member. Finally, the network complexity is reduced by maximizing the number of cluster members without congestion.

(2)

We propose a node degree and location-based cluster member selection mechanism to reduce network complexity by increasing the average number of cluster members. Firstly, the average number of cluster members is improved by removing nodes with node degree less than the maximum number of cluster members to avoid clusters with very few cluster members. Then, based on location, nodes farthest from the cluster head are removed to increase cluster cohesion. Thereby, the maximum number of cluster members that can be accommodated in a cluster is increased by enhancing the upper limit of intra-cluster information transmission.

(3)

We propose an novel priority-based clustering mechanism. Nodes are assigned cluster priority based on the maximum cluster member constraint without congestion. This approach ensures that as many clusters as possible have a number of cluster members close to the maximum, thus reducing the total cluster number after clustering completion. Ultimately, the purpose of maximizing the reduction of network complexity without congestion is achieved.

The remainder of this paper is organized as follows. In Section 2, we present the related work. In Section 3, we show our proposed LLCP. In Section 4, simulation are illustrated and analyzed before summarizing the paper in Section 5.

2. Related Work

The clustering protocol employs specific rules to cluster nodes with similar characteristics, aiming to reduce network complexity, achieve energy balance, and prolong network lifetime [15,16,17,18,19,20,21]. Existing clustering rules encompass considerations based on distance, node density, residual energy, and depth. Next, we summarized and analyzed the existing work according to the clustering rules.

2.1. Related Work

Clustering based on the distance to the cluster head is a simple yet effective clustering strategy. It has garnered significant attention from researchers due to its potential to reduce energy consumption by shortening the transmission distance between cluster members and the cluster head. One prominent example of such an approach is LEACH [12], which stands for low-energy adaptive clustering hierarchy. LEACH introduces a distributed clustering scheme where nodes locally compute the probability of being selected as a cluster head. It also incorporates adaptive clustering and cluster head rotation mechanisms to ensure energy balance among nodes. By allowing nodes with higher energy levels to take turns serving as cluster heads, LEACH aims to prolong the network lifetime. Moreover, LEACH proposes an information aggregation scheme to optimize the cluster number and reduce the demand for communication resources. This approach facilitates efficient data aggregation, further contributing to energy savings. In large-scale networks, LEACH demonstrates its effectiveness by combining clustering-based energy-efficient routing with channel access mechanisms. This integration helps reduce delay and enhance the overall network lifespan. A distance and energy-constrained k-means clustering scheme (DEKCS) is proposed to extend network lifetime in [11]. DEKCS selects cluster heads based on node locations and their remaining energy levels, dynamically updating the energy levels of potential cluster heads to ensure network disconnection only occurs after the energy depletion of all nodes. An energy-efficient multi-level adaptive clustering routing algorithm for underwater wireless sensor networks (ACUN) is proposed in [22]. In a hierarchical network structure, ACUN determines the competitive radius based on the distance from the cluster head to the sink node and the remaining energy of the cluster head. This approach helps avoid premature failure of clusters located far from the sink node due to energy depletion. Factors influencing cluster head election include node residual energy and energy consumption along the transmission path. ACUN selects a node with more remaining energy as the cluster head, achieving energy balance while optimizing network energy consumption.

An for reliable data transfer (ANCRP) is proposed in [23]. ANCRP partitions the network space into small cubic regions, with each region forming a cluster. An anchored node is deployed at the center of each cubic region to serve as the cluster head, while source nodes are randomly distributed. Source nodes transmit data to the cluster head, which aggregates the data through multi-hop transmission via other cluster heads to the sink node located on the water surface. Additionally, by employing a mechanism similar to ad hoc networks, ANCRP enables the selection of available cluster member to relay data for area recovery, thus enhancing the reliability of information transmission. A game-theory-based clustering scheme (GTC) is proposed in [24]. At the beginning of cluster head election, each node makes a decision based on the Nash equilibrium to maximize its own benefits. The network is partitioned into uneven regions to ensure a more uniform distribution of cluster head energy consumption, ultimately achieving energy balance and extending network lifetime. In addition, an unequal clustering method based on particle swarm optimization (UCPSO) is proposed in [25]. Cluster head selection is based on residual energy, distance to the sink node, and cluster head load to dynamically update the cluster range, aiming to achieve energy balance among network nodes. Moreover, relay selection is based on energy consumption and hop count for information transmission from cluster heads to the sink node, thereby reducing energy consumption.

Clustering based on node density is more conducive to achieving energy balance, thereby prolonging the network lifetime. In [26], an energy-efficient distributed node clustering routing protocol with mobility pattern support (DNC-MPRP) is proposed to reduce energy consumption during information transmission over long distances and deep areas, while avoiding inaccurate routing through mobile patterns. In DNC-MPRP, the network is divided into two dense areas for short and long-distance communication. Cluster heads select nodes for clustering in different ranges, reducing the energy consumption of cluster members, and information transmission only occurs when the coverage area is within the network communication range. A energy hole mitigation through optimized cluster head selection and strategic routing (EOCSR) to extend network lifetime is proposed in [27]. EOCSR utilizes the ant colony optimization algorithm to select optimal cluster heads based on residual energy, node density, distance to the sink node, average network energy, and error tolerance factor. It achieves energy balance through power control for relay node selection and other mechanisms. In [28], a centralized control-based clustering scheme (CCCS) is proposed to achieve energy balance. CCCS utilizes a node density-based clustering algorithm, an energy-loss-based cluster head election mechanism, and relay node and relay cluster selection to balance node energy consumption.

Clustering based on residual energy can effectively prevent nodes from failing prematurely, thus extending the network lifetime. In [29], an energy-balanced unequal layering clustering (EULC) is proposed to improve energy efficiency. EULC employs a non-uniform clustering scheme based on node depth to address hotspots by constructing clusters with different ranges on the same layer. By considering parameters such as residual energy, node degree, and distance to the sink node, EULC achieves a more even distribution of cluster heads on the same layer. Furthermore, it adjusts the cluster range based on the distance between cluster heads and the sink node, allowing clusters closer to the sink node to have a smaller coverage area. Additionally, relay node selection based on residual energy and depth reduces the energy consumption required for inter-cluster communication. In [30], an energy efficient underwater wireless sensor networks clustering protocol (EEUCP) is proposed to improve energy efficiency, avoid communication voids, and enhance network quality of service. EEUCP employs the K-means algorithm for clustering and utilizes fuzzy logic for optimal cluster head selection. To address communication voids, EEUCP utilizes periodic fuzzy trust values for reliable relay forwarding, thereby achieving the goals of extending the network lifetime and improving network quality of service. In [31], an energy-aware multilayer clustering-based butterfly optimization routing (MCBOR) is proposed. MCBOR selects cluster heads based on residual energy, communication overhead, node coverage range, and processing energy consumption to reduce energy consumption and extend the network lifetime. Furthermore, through butterfly optimization algorithm, MCBOR selects nodes with high link quality, minimum distance, and more residual energy as relays, thereby improving packet delivery ratio and reducing energy consumption.

Due to the effectiveness of depth-based clustering protocols in addressing hotspot issues, it has attracted significant attention from researchers for optimization. In [32], an energy-aware multilevel clustering scheme (EAMC) is proposed. The protocol divides a cylindrical region into multiple layers, each containing several blocks forming a cluster. Communication is conducted using a routing scheme from the seabed to the sea surface to mitigate the effects of water pressure on communication. Additionally, timely replacement of cluster heads is performed when the energy of a cluster head decreases to a threshold to achieve energy balance and prolong the network lifetime. In [33], a floating nodes assisted cluster-based routing (FNCBR) for efficient data collection is proposed. FNCBR divides the entire network area into an appropriate number of cubes, clustering them within each cube. A floating node is deployed at the sea surface of each cube, while two fixed cluster heads are placed at different depths, connected to the floating node via cables. Data generated by source nodes is relayed through cluster heads or directly transmitted to the floating node and then forwarded to the control center, facilitating efficient data collection.

2.2. Problem Statement

The performance of network clustering is significantly influenced by the node load and location, but existing clustering protocols fail to address this issue. When the intra-cluster load surpasses the transmission capacity, congestion ensues, leading to a drastic rise in end-to-end packet delay or even network collapse. Conversely, if the load within a cluster falls below its transmission capacity, the proliferation of clusters results in heightened network complexity.

To address this issue, we propose a node load and location-based clustering protocol that takes into account both node load and location. Firstly, we compute the maximum cluster member number based on node load and location to avoid congestion while minimizing network complexity. Secondly, employing a cluster member selection mechanism to achieve optimal cluster member selection, we strive to maximize the node number within a cluster without congestion, enhance cluster cohesion, and reduce the cluster number. Finally, through a priority-based clustering mechanism, we prioritize node clustering, aiming to increase the average number of cluster members under congestion-free conditions. Ultimately, the goal of avoiding congestion while minimizing network complexity is achieved.

3. LLCP

3.1. Network Modem

We consider a large-scale multi-hop network designed for environmental monitoring. The network consists predominantly of sensor nodes and a limited number of sink nodes, as illustrated in Figure 1. Each node is equipped with a half-duplex transducer, with sink nodes additionally featuring wireless radio frequency communication devices. We first cluster the sensor nodes. Then, the cluster members collect the environmental data and aggregate the data to the cluster head. It is assumed that all nodes possess their own location [34] and data packets are generated at the beginning moment of the unit time.

In order to enhance the accuracy of environmental data, a considerable number of sensor nodes must be strategically deployed within a designated area. However, clustering these nodes based on their communication range may lead to clusters with an excessive nodes. Such a scenario can cause network congestion when the load within a cluster surpasses its information transmission capacity, as illustrated in Figure 1. For instance, let us consider cluster 2, where node 1 serves as the cluster head with a maximum cluster members number of 5. However, the neighboring nodes of node 1, including nodes 2–8, amount to 7 nodes in total. If all of these nodes were to be incorporated into cluster 2, congestion could arise due to the potential inability to transmit certain data in a timely manner. To mitigate congestion, it becomes imperative to remove nodes 7 and 8 from cluster 2. Addressing this challenge, we propose LLCP that leverages both node load and location information to determine cluster members. By employing this approach, we aim to prevent congestion while optimizing network simplification.

Next, we give the definitions of the parameters in LLCP, as shown in

Table 1. Parameter definitions.

Parameter	Description
$TH{C}_{max}$	The upper limit of intra-cluster information transmission capacity
$U{H}_{max}$	The max channel utilization of the cluster head
R	The communication rate of the physical layer
$TF$	The duration of one time frame for the cluster head
$T{I}_{min}$	The minimum idle time of the cluster head within one time frame
$TM{C}_i^M$	The time slot scheduling moment of cluster member i in time frame M
$T{S}_i^M$	The time slot length of cluster member i in time frame M
$T{P}_i$	The propagation delay from cluster member i to the cluster head
$U{H}^M$	The channel utilization of the cluster head in the Mth time frame
$T{I}_i^M$	The idle waiting time of the cluster head caused by cluster member i in the Mth time frame
$T_{prot}$	The guard interval
$TI{H}^M$	A gap between the arrival time of the first data packet from the next time frame at the cluster head and the arrival time of the last cluster member’s data packet from the previous time frame
$N_c$	The number of cluster members
$N_c^{max}$	The maximum number of cluster members
$T{S}_{N_H}^M$	The time slot length of the cluster head in the time frame M
$N_r$	The node number to be removed
$N_t$	The total node number within the cluster
$ND$	The node degree
$N_{neighbor}$	The number of neighboring node
$A{G}_c$	The cluster cohesion
$D_i$	The distance between cluster member i and the cluster head
$N{S}_{neighbor}$	The neighbor node set
$NS{N}_{temp}^i$	The neighbor node set of neighbor node i
$Loc$	The node locations
$N{D}_{min}$	The minimum neighbor node number
$D_{max}$	The maximum distance
$D{N}_{max}$	The node farthest from the cluster head
$N_{c-i}^{max}$	The maximum number of cluster members when clustering with node i and its neighboring nodes
$ND{N}_{min}$	The node with the minimum node degree
$N{S}_{temp}$	The adjusted neighbor node set
$NodeTyp{e}_i$	The node type of node i
$C_p$	The clustering priority
$N{S}_{neighbor}^i$	The neighbor node set of neighbor node i
$E\left(TD\right)$	The experimental average end-to-end delay
$E\left(NC\right)$	The experimental average cluster number
$N_{sim}$	The total number of independent replication simulation
$T{D}_j^i$	The end-to-end delay of the jth data packet in the ith independent replication simulation
$N_p^i$	The total number of successfully received data packets in the ith independent replication simulation
$N{C}^i$	The cluster number in the ith independent replication simulation

.

The workflow of the clustering protocol is as follows. First, nodes broadcast the neighbor query packet. Neighboring nodes that have not yet joined any clusters respond to this packet by sending a neighbor reply packet. Second, nodes utilize node load and location information from neighboring nodes to assign clustering priority to local cluster through node load and location-based cluster member number optimization mechanism and priority-based clustering mechanism. Next, redundant neighboring nodes are removed based on node degree and location-based cluster member selection mechanism. Finally, these steps are iteratively repeated until all nodes have been clustered.

3.2. Frame Structure

In this section, we further introduce LLCP by introducing the frame structure as illustrated in Figure 2.

We define the following parameters in

Table 2. Frame structure parameter definitions.

Parameter	Description
Src	Source node address
Dest	Destination node address
Type	Packet type
CM $N_c$	Address of cluster member $N_c$
TS $N_c$	Time slot scheduling of sensor node $N_c$
CF Packet	Cluster formation packet
Slot $N_c$	Time slot of cluster member $N_c$
Slot $N_H$	Time slot of cluster header
Idle	Idle waiting time
CF Phase	Cluster formation phase

for easier understanding of the frame structure.

First, we introduce the concept of a time frame. In LLCP, a time frame primarily consists of two phases: the cluster formation phase and the data packet transmission phase. During the cluster formation phase, cluster formation is performed. The cluster head broadcasts the cluster formation results and channel access information. In the data packet transmission phase, sensor information is aggregated from cluster members to the cluster head. Each cluster member transmits the local data packet to the cluster head during this phase.

Next, we introduce the cluster formation packet. The cluster formation packet is composed of two parts: the cluster formation packet header and the cluster formation information. The cluster formation packet header includes the source node address, the destination node address, and the packet type. The source node address is the address of the node that sends the packet. The destination node address is the information of the receiving node of the packet. Since the cluster formation packet is a broadcast packet, the destination node address is a special address, such as 255. The packet type indicates the type of the packet, with the cluster formation packet type specifically identified as Type_Cluster_Formation. The cluster formation information includes address of all cluster members from cluster member 1 to cluster member $N_c$ and channel access information.

Finally, we introduce the data packet. The data packet consists of two parts: the data packet header and the sensor information. The data packet header is similar to cluster formation packet header and includes the source node address, the destination node address, and the packet type. The data packet type specifically identified as Type_Data. The sensor information is the data collected by the sensors configured on the cluster members.

The intra-cluster information transmission capacity is primarily limited by the idle waiting time of the cluster head. There are two main scenarios that lead to idle waiting time at the cluster head. The first scenario occurs when the arrival times of data packets from different cluster members to the cluster head are not continuous. If the distance between adjacent cluster members and the cluster head is significantly different or the load is relatively small, resulting in the next cluster member’s data packet not yet having arrived at the cluster head after the previous cluster member’s data packet has finished reception, there will be idle waiting time. The second scenario arises when there are few cluster members or when the cluster members have a low load, causing idle waiting time within a time frame even after the data packets of all nodes have been finished reception. In LLCP, we address these issues by selecting the optimal cluster members and the optimal number of cluster members. Ultimately, the purpose of maximizing the reduction of network complexity without congestion is achieved.

3.3. Node Load and Location-Based Cluster Member Number Optimization Mechanism

In this section, we illustrate how to determine the optimal number of cluster members based on node load and location. One of the main goals of clustering is to simplify the network. Network complexity can be reduced by minimizing the number of clusters in the network while avoiding congestion. However, if clustering is performed solely based on communication range without considering node load and location, it may result in numerous nodes being assigned to the same cluster. When the load within a cluster surpasses its information transmission capacity upper limit, congestion can occur, leading to a significant increase in end-to-end delay or even network collapse.

To address this issue, we propose node load and location-based cluster member number optimization mechanism. Initially, we compute the upper limit of intra-cluster information transmission capacity according to the channel access protocol being utilized. Then, we determine the maximum number of cluster members based on this calculated upper limit.

Cluster heads play a crucial role in gathering data within their designated clusters in UASNs. Consequently, upon completion of clustering, all data collected by cluster members will be directed towards the cluster head. Hence, the upper limit of intra-cluster information transmission capacity is primarily determined by the channel utilization of the cluster head. Assuming the network operates in single-channel mode, the expression for the upper limit of intra-cluster information transmission capacity $TH{C}_{max}$ can be delineated as follows:

$$\begin{array}{cc}\hfill TH{C}_{max}=& U{H}_{max}R\hfill \end{array}$$

(1)

where $U{H}_{max}$ represents the max channel utilization of the cluster head and R symbolizes the communication rate of the physical layer, indicating the amount of information the cluster head can receive per unit time.

The channel utilization of the cluster head is primarily affected by the idle waiting time. When the cluster head operates continuously within a single time frame, the channel utilization reaches its maximum. The max channel utilization of the cluster head $U{H}_{max}$ can be formulated as:

$$\begin{array}{cc}\hfill U{H}_{max}=& \frac{TF-T{I}_{min}}{TF}\hfill \end{array}$$

(2)

where $TF$ represents the duration of one time frame for the cluster head and $T{I}_{min}$ denotes the minimum idle time of the cluster head within one time frame, which is influenced by factors such as propagation delay, cluster member number, and channel access protocol.

Our protocol is designed for high-load scenarios where the TDMA protocol, known for its effective contention avoidance, performs admirably. Hence, we assume a TDMA-based channel access protocol within the cluster, omitting ACK for message confirmation. However, for cluster members i and $i+1$, significant discrepancies in propagation delay to the cluster head might disrupt the cluster head’s continuous information reception, resulting in idle waiting time. Consequently, the idle waiting time of the cluster head caused by cluster member i in the Mth time frame $T{I}_i^M$ can be expressed as:

$$\begin{array}{cc}\hfill T{I}_i^M=& TM{C}_{i+1}^M+T{P}_{i+1}-TM{C}_i^M-T{S}_i^M-T{P}_i\hfill \end{array}$$

(3)

where $TM{C}_i^M$ denotes the time slot scheduling moment of cluster member i in time frame M, $TM{C}_{i+1}^M$ denotes the time slot scheduling moment of cluster member $i+1$ in time frame M, $T{S}_i^M$ represents the time slot length of cluster member i in time frame M, $T{P}_i$ signifies the propagation delay from cluster member i to the cluster head, and $T{P}_{i+1}$ indicates the propagation delay from cluster member $i+1$ to the cluster head. Obviously, the occurrence of idle waiting time primarily depends on the difference in propagation delay between adjacent transmitting cluster member and the cluster head, as well as the length of time slot, which is mainly determined by the node load.

To achieve collision avoidance while minimizing idle waiting time, the scheduling moments of adjacent cluster members’ time slots can be expressed as:

$$TM{C}_{i+1}^M=TM{C}_i^M+max(T{S}_i^M+T{P}_i-T{P}_{i+1},0)+T_{prot}$$

(4)

where $T_{prot}$ is the guard interval.

When the propagation delay difference is sufficiently small or the node load is sufficiently high, i.e., $T{S}_i^M+T{P}_i-T{P}_{i+1}>0$, this means that cluster member $i+1$ needs to wait for a certain period after cluster member i starts transmitting. Otherwise, there is a risk of collisions, as the cluster head might not have finished receiving the data packet from cluster member i when the data packet from cluster member $i+1$ arrives. Conversely, when the propagation delay difference is significant or the node load is small enough, i.e., $T{S}_i^M+T{P}_i-T{P}_{i+1}<0$, indicating that cluster member $i+1$ can start transmitting simultaneously with cluster member i without causing collisions at the cluster head.

Furthermore, if there is a gap between the arrival time of the first data packet from the next time frame at the cluster head and the arrival time of the last cluster member’s data packet from the previous time frame, it can also lead to idle time for the cluster head. This idle time reduces the channel utilization of the cluster head. This period of time $TI{H}^M$ can be expressed as:

$$TI{H}^M=max(TF+TM{C}_1^{M+1}+T{P}_1-TM{C}_{N_c}^M-T{S}_{N_c}^M-T{P}_{N_c}-T_{prot},0)$$

(5)

where $N_c$ denotes the number of cluster members and $TF$ usually corresponds to the interval between data packet generations of cluster members. Obviously, increasing the number of cluster members can effectively reduce this idle waiting time.

According to (3) and (5), the channel utilization of the cluster head in the Mth time frame can be represented as:

$$\begin{array}{cc}\hfill U{H}^M=& \frac{TF-{\sum }_{i=1}^{N_c-1}T{I}_i^M-TI{H}^M}{TF}\hfill \end{array}$$

(6)

Obviously, channel utilization is mainly influenced by idle waiting time in two scenarios. In cases where the cluster head experiences idle time due to distant adjacent cluster members, starting information transmission from the nearest to the farthest based on their distance to the cluster head, and minimizing the distance between cluster members and the cluster head, can effectively reduce $T{I}_i^M$. As for $TI{H}^M$, selecting an optimal number of cluster members can effectively reduce this idle waiting time.

Next, we analyze the maximum number of cluster members. The data packet generated by the cluster members within the current time frame needs to be transmitted within the current time frame, otherwise part of the data packets cannot be transmitted in time leading to network congestion. In order to avoid congestion, the first cluster member should transmit the data packet at the beginning moment of the time frame. At the same time, the moment when the last cluster member’s data packet completes reception at the cluster head is smaller than the arrival moment of the first cluster member’s data packet in the next time frame. Therefore, the congestion avoidance constraints are as follows:

$$TF+T{P}_1-{\displaystyle \sum _{i=1}^{N_c-1}}max(T{S}_i^M+T{P}_i-T{P}_{i+1},0)-T{S}_{N_c}^M-T{P}_{N_c}-T{S}_{N_H}^M-(N_c+1)T_{prot}\ge 0$$

(7)

where $T{S}_{N_H}^M$ is the time slot length of the cluster head in the time frame M, which is used to transmit the data packets aggregated to the cluster head.

As the number of cluster members increases, the duration for the cluster head to receive data packets also lengthens. This implies that the time to receive data packet from the last cluster member in the current time frame approaches the time when the data packet from the first cluster member for the next time frame arrives. Consequently, the idle waiting time for the cluster head diminishes. Under the condition of no congestion, the constraint on the maximum number of cluster members can be stated as follows:

$$T{S}_{N_c+1}^M+T_{prot}>TF+T{P}_1-{\displaystyle \sum _{i=1}^{N_c-1}}max(T{S}_i^M+T{P}_i-T{P}_{i+1},0)-T{S}_{N_c}^M-T{P}_{N_c}-T{S}_{N_H}^M-(N_c+1)T_{prot}\ge 0$$

(8)

Therefore, the maximum $N_c$ that satisfies the above constraints is considered the maximum number of cluster members $N_c^{max}$.

When the cluster head continuously receives data packets from cluster members, the upper limit of intra-cluster information transmission capacity is achieved. Assuming uniform load distribution among all nodes and sufficiently close distances between adjacent transmitting nodes to prevent idle waiting time, the maximum number of cluster members in (8) can be simplified as:

$$\begin{array}{cc}\hfill N_c^{max}=& \lfloor \frac{TF}{TS}\rfloor -1\hfill \end{array}$$

(9)

where $TS$ represents the length of time slot.

In other words, when the number of cluster members increases to the point where the cluster head almost continuously receives data packets, the intra-cluster information transmission capacity reaches its peak, and the number of cluster members also reaches its maximum. That is, minimum network complexity without congestion can be achieved when the number of cluster members is $N_c^{max}$.

3.4. Node Degree and Location-Based Cluster Member Selection Mechanism

In this section, we elaborate on the node degree and location-based cluster member selection mechanism, as illustrated in Figure 3. The selection of cluster members aims to achieve three objectives: maximizing the number of cluster members without congestion, enhancing cluster cohesion, and minimizing the total cluster number.

To begin with, in order to maximize the number of cluster members without congestion, we remove a portion of the nodes from the cluster when the node number exceeds $N_c^{max}$. This prevents congestion caused by an excessively large number of cluster members, which could lead to some data packets being unable to be transmitted within the current time frame. The node number to be removed, denoted as $N_r$, can be calculated as follows:

$$\begin{array}{cc}\hfill N_r=& N_t-N_c^{max}\hfill \end{array}$$

(10)

where $N_t$ stands for the total node number within the cluster, which corresponds to the available neighboring nodes of cluster head.

Next, we outline the approach to minimize the cluster number. To achieve this, it is crucial to ensure that the node number in each cluster closely matches the maximum number of cluster members. Therefore, we define the node degree as follows:

$$\begin{array}{cc}\hfill ND=& N_{neighbor}\hfill \end{array}$$

(11)

in other words, the node degree equals the number of neighboring node.

During the process of removing redundant nodes, we initially select nodes with a degree less than $N_c^{max}$. This ensures that nodes with a degree less than $N_c^{max}$ are preferably not included in other clusters, thereby reducing the number of cluster members. Consequently, this approach aims to make the cluster member number in all clusters as close as possible to $N_c^{max}$, thereby maximizing the reduction in the total cluster number. As shown in Figure 3, when node 1 needs to remove redundant nodes, node 2 is the neighbor node with the lowest node degree. The node 2 is preferred to be removed because it satisfies the (7) when it is clustered with its neighboring nodes, but it does not satisfy the (8). In this manner, the probability of nodes 6/7/8 and node 2 clustering can be increased. Thus, the cluster member number in the cluster is increased when node 2 is clustered as a cluster head.

Next, we demonstrate how to enhance cluster cohesion and minimize the total cluster number while removing excessive nodes. According to (3), it is evident that when the distance difference between adjacent transmitting nodes and the cluster head is small, or when the load is high, idle waiting time can be effectively reduced. Therefore, we initially sort the cluster member based on their distance from the cluster head, arranging them from nearest to farthest, and renumber them accordingly.

The cluster cohesion, denoted as $A{G}_c$, can be represented as:

$$\begin{array}{cc}\hfill A{G}_c=& {\displaystyle \sum _{i=1}^{N_c-1}}{D}_i\hfill \end{array}$$

(12)

where $D_i$ represents the distance between cluster member i and the cluster head.

As shown in Figure 3, when node 1 needs to remove redundant nodes. Currently, all neighboring nodes that not satisfy the (7) when clustering have been removed. Node 4 is the farthest node from node 1. When node 4 is removed, as per (12), removing cluster member that are farther from the cluster head enhances cluster cohesion. Consequently, this allows for an increase in the maximum number of cluster members that the cluster can accommodate by reducing the idle waiting time for the cluster head.

To provide a deeper insight into the cluster member selection mechanism, we propose a cluster member selection algorithm based on node degree and location, as shown in Algorithm 1.

Algorithm 1 Cluster Member Selection Algorithm Based on Node Degree and Location

Input: $N{S}_{neighbor},NS{N}_{temp}^i,TS,Loc$ Output: $N{S}_{temp}$ 1: Initialization $N{D}_{min}=100,D_{max}=0$ 2: $N{S}_{temp}\leftarrow N{S}_{neighbor}$ 3: while $N{S}_{temp}$ not satisfying (8) do 4:     for $i=1;i\le SizeOf\left(N{S}_{temp}\right)$ do 5:         Calculate the distance $D_i$ between $N{S}_{temp}^i$ and the cluster head 6:         if $D_{max}<D_i$ then 7:               $D_{max}\leftarrow D_i$ 8:               $D{N}_{max}\leftarrow N{S}_{temp}^i$ 9:         end if 10:       $N{D}_i=SizeOf\left(NS{N}_{temp}^i\right)$ 11:         if $N{D}_{min}>N{D}_i$ then 12:               $N{D}_{min}\leftarrow N{D}_i$ 13:               $ND{N}_{min}\leftarrow N{S}_{temp}^i$ 14:         end if 15:     end for 16:     if The neighbor of $ND{N}_{min}$ satisfying (7) then 17:         Remove $ND{N}_{min}$ from $N{S}_{temp}$ 18:     else if The neighbor of $ND{N}_{min}$ not satisfying (7) then 19:         Remove $D{N}_{max}$ from $N{S}_{temp}$ 20:     end if 21: end while 22: return  $N{S}_{temp}$

The algorithm takes several inputs: the neighbor node set $N{S}_{neighbor}$, the neighbor node set $NS{N}_{temp}^i$ of neighbor node i, the time slot length $TS$, and the locations $Loc$ of every node. The output is the adjusted neighbor node set $N{S}_{temp}$. Line 1 initializes the minimum neighbor node number $N{D}_{min}$ to 100 and the maximum distance $D_{max}$ to 0, providing starting values for subsequent comparisons. In line 2, the neighbor node set $N{S}_{neighbor}$ is copied to a temporary variable $N{S}_{temp}$ to avoid altering the original set. Line 3 iterates to check whether the neighbor node set $N{S}_{temp}$ satisfies the constraint of the maximum number of cluster members; if not, excess nodes are removed. Lines 4–15 loop through all nodes in $N{S}_{temp}$ to find the node farthest from the cluster head $D{N}_{max}$ and the node with the minimum node degree $ND{N}_{min}$. Lines 5–9 calculate the distance from each node to the cluster head and determine if the node is the farthest node. If so, it updates $D_{max}$ and $D{N}_{max}$ for subsequent removal. Lines 10–14 calculate the node degree of each node and identify the node with the minimum node degree. If found, it updates $N{D}_{min}$ and $ND{N}_{min}$ for subsequent removal. In line 16, if the neighbor node set of node $ND{N}_{min}$ meet the maximum cluster member constraint, i.e., the minimum number of neighbor nodes is less than $N_c^{max}$, it indicates a node has a node degree less than $N_c^{max}$, so the node with the minimum node degree is removed to avoid clusters with too few cluster members. In line 18, if the neighbor node set of node $ND{N}_{min}$ does not satisfy the constraint, i.e., the minimum number of neighbor nodes is greater than $N_c^{max}$, it means all node degrees are greater than $N_c^{max}$, so the node farthest from the cluster head is removed to improve cluster cohesion. After the loop in line 3, the algorithm produces the set $N{S}_{temp}$ containing the maximum number of cluster members $N_c^{max}$, representing the optimal cluster member set.

3.5. Priority-Based Clustering Mechanism

In this section, we delve into how nodes within the network cluster efficiently to optimize its structure. Our aim is to ensure that the cluster member number in each cluster closely matches the predefined maximum cluster member number $N_c^{max}$. The primary goal of this priority-based clustering mechanism is to simplify the network complexity, thus enhancing its operational efficiency and stability.

The priority-based clustering mechanism primarily involves prioritizing the clustering of different nodes based on predefined constraints, mainly outlined in (7) and (8).

Firstly, for node i, if forming a cluster with node i and its neighboring nodes satisfies the constraint in (8), indicating that the cluster member number has reached the maximum cluster member number $N_{c-i}^{max}$ of node i, then this cluster is assigned the highest priority for clustering and node i is elected as cluster head. This cluster accommodates as many cluster members as possible without causing congestion. If some neighboring nodes are prioritized by other clusters, it may result in the cluster member number of this cluster being less than its $N_{c-i}^{max}$. To prevent nodes in this cluster from being prioritized by other clusters, the cluster is given the highest clustering priority to ensure that the cluster member number equals $N_{c-i}^{max}$, thereby maximizing the reduction in network complexity.

Next, if forming a cluster with node i and its neighboring nodes does not satisfy the constraint in (7), indicating that the cluster member number exceeds the $N_{c-i}^{max}$, then this cluster is assigned a lower priority for clustering and node i is elected as cluster head. In this scenario, it is necessary to remove surplus neighboring nodes through the cluster member selection mechanism to ensure that the cluster member number remains equal to $N_{c-i}^{max}$ after clustering. During the process of removing surplus nodes, priority is given to removing nodes with degrees less than $N_{c-i}^{max}$ to minimize the reduction in the cluster member number below $N_{c-i}^{max}$. Additionally, by prioritizing the removal of nodes distant from the cluster head, both the local cluster cohesion is enhanced and its impact on other clusters is reduced. Moreover, this approach avoids situations where removed nodes need to form separate clusters due to the absence of neighboring nodes, thereby minimizing the average cluster member number within clusters.

Finally, for node i, if forming a cluster with node i and its neighboring nodes satisfies the constraint in (7) but not the constraint in (8), indicating that the cluster member number is less than the $N_{c-i}^{max}$, then this cluster is assigned the lowest priority for clustering and node i is elected as cluster head. In this case, there is no need to remove nodes. Assigning the lowest clustering priority effectively reduces the impact on other clusters and avoids situations where some nodes are occupied in other clusters, leading to fewer cluster members in those clusters than $N_{c-i}^{max}$.

To provide a deeper insight into the cluster mechanism, we propose a cluster algorithm, as shown in Algorithm 2.

The algorithm takes as input the set of neighboring nodes $N{S}_{neighbor}$. In lines 1–10, clusters with the highest clustering priority are processed first. In line 1, all nodes are iterated through to determine the priority of the cluster to which each node belongs, where $N_t$ is the total node number. In line 2, based on the node type $NodeTyp{e}_i$, it is determined whether clustering is necessary. If the node type is Type_Sensor, it indicates that the cluster has not joined any other clusters yet, and thus, clustering is performed. If the node type is Type_Head or Type_Member, it means that the node has already joined another cluster, and clustering is not required. In line 3, a neighbor node query packet is sent to query the neighbor nodes of the node i. Active querying helps address hidden node issues and clustering failure issues. In line 4, the clustering priority for the ith node’s neighbor node set is determined based on (8). In line 5, the clustering priority $C_p$ is assigned. In line 6, cluster member selection is performed based on Algorithm 1. In line 7, cluster member and cluster head types are modified by broadcasting cluster formation packet. The process is repeated for clusters with lower priorities (lines 11–20) and clusters with the lowest priority (lines 21–30).

Algorithm 2 Cluster Algorithm

Input: $N{S}_{neighbor}$ 1: for  $i=1;i\le N_t$  do 2:     if $NodeTyp{e}_i$ ==Type_Sensor then 3:         Query the neighboring nodes of node i 4:         if $N{S}_{neighbor}^i$ satisfying (8) then 5:            $C_p=highest$ 6:            Perform clustering according to Algorithm 1 7:            Modify the node type to Type_Head or Type_Member 8:         end if 9:     end if 10: end for 11: for $i=1;i\le N_t$  do 12:     if $NodeTyp{e}_i$ ==Type_Sensor then 13:         Query the neighboring nodes of node i 14:         if $N{S}_{neighbor}^i$ not satisfying (7) then 15:            $C_p=lower$ 16:            Perform clustering according to Algorithm 1 17:            Modify the node type to Type_Head or Type_Member 18:         end if 19:     end if 20: end for 21: for  $i=1;i\le N_t$  do 22:     if $NodeTyp{e}_i$ ==Type_Sensor then 23:         Query the neighboring nodes of node i 24:         if $N{S}_{neighbor}^i$ satisfying (7) but not satisfying (8) then 25:            $C_p=lowest$ 26:            Perform clustering according to Algorithm 1 27:            Modify the node type to Type_Head or Type_Member 28:         end if 29:     end if 30: end for

4. Simulation

We present extensive simulation results to verify and understand our proposed LLCP. All evaluated clustering protocols have been implemented using NS-3. NS-3 is a high fidelity and flexible packet level simulator. All simulations run for a minimum of 500 s. Five independent repetitions were conducted under the same simulation parameters. Thus, the impact of random topology on the protocol performance is minimized. The sensor nodes in the simulation are randomly deployed in a square area of 5000 m × 5000 m. We also compared the performance of our proposed protocol LLCP with DEKCS. Our manuscript primarily investigates the impact of intra-cluster load on the performance of clustering protocol. An important factor influencing intra-cluster load is the number of cluster members, so we focus on analyzing the impact of the cluster member number on the performance of our proposed clustering protocol. DEKCS is a clustering protocol based on communication range, and the communication range significantly affects the number of cluster members. Therefore, we have chosen DEKCS, which has good comparability, as the benchmark protocol for our study. We do not consider cluster head election and node energy limits.

We chose the following simulation parameters, as shown in

Table 3. Simulation parameters.

Parameter	Values
Sensor node number	50–500
Packet size	25–325 bytes
Node location	Random deployment
Number of independent replication simulation	5
Communication range	200–2200 m

.

In the simulations, we select average end-to-end delay and average cluster number as the performance indicates, where the average end-to-end delay is used to indicate the congestion state and the average cluster number is used to indicate the network complexity.

The experimental average end-to-end delay $E\left(TD\right)$ in simulation is denoted by:

$$\begin{array}{c}\hfill E\left(TD\right)=\frac{{\displaystyle \sum _{i=1}^{N_{sim}}}{\displaystyle \sum _{j=1}^{N_p^i}}T{D}_j^i}{{\displaystyle \sum _{i=1}^{N_{sim}}}{N}_p^i}\end{array}$$

(13)

where $N_{sim}$ is the total number of independent replication simulation of different random number generators for the same simulation parameters, $T{D}_j^i$ is the end-to-end delay of the jth data packet in the ith independent replication simulation, and $N_p^i$ is the total number of successfully received data packets in the ith independent replication simulation.

The experimental average cluster number $E\left(NC\right)$ in simulation is denoted by:

$$\begin{array}{c}\hfill E\left(NC\right)=\frac{{\displaystyle \sum _{i=1}^{N_{sim}}}N{C}^i}{N_{sim}}\end{array}$$

(14)

where $N{C}^i$ is the cluster number in the ith independent replication simulation.

4.1. Performance under Different Node Numbers

Figure 4 and Figure 5 demonstrate the performance in terms of the average cluster number and the average end-to-end delay under different node numbers. The simulation parameters are chosen as follows: the data packet size is 75 bytes and the communication range is 700 m. The simulation results indicate that our proposed LLCP achieves the lowest average end-to-end delay, and maximizing the reduction of network complexity while avoiding congestion.

Figure 4 shows the performance of the average cluster number. When the network does not experience congestion, a lower average cluster number indicates lower network complexity. As the node number increases, the cluster number in the LLCP protocol gradually increases, while the cluster number in DEKCS initially increases and then remains almost constant. The node number primarily affects the cluster number by changing the node number within the communication range.

For DEKCS, when the node number is small, even if the communication range remains the same, some areas might have no nodes. Therefore, the cluster ranges do not cover the entire network, resulting in fewer cluster number. As the node number increases and exceeds 250, the network becomes densely populated with randomly distributed nodes, leaving almost no empty areas within the network range. Consequently, the cluster ranges cover the entire network range. We conducted five independent repeated simulations, and although the average cluster number fluctuated slightly, it did not increase significantly and remained stable.

For LLCP, despite a constant communication range, the node number within each cluster is optimized based on node load and location information to avoid congestion while minimizing network complexity. Therefore, as the node number increases, the optimal node number per cluster is maintained by increasing the cluster number to prevent intra-cluster congestion. Hence, the average cluster number increases with the node number.

Figure 5 shows the performance of the average end-to-end delay. Simulation results indicate that as the node number increases, the average end-to-end delay of DEKCS initially remains almost unchanged but then increases sharply. In contrast, the average end-to-end delay of LLCP remains nearly constant.

DEKCS clusters based on the communication range. When the node number is small, nodes are sparsely distributed, resulting in fewer nodes per cluster. The intra-cluster load does not exceed the upper limit of the intra-cluster information transmission capacity, allowing timely data packet transmission and resulting in low average end-to-end delay, similar to the non-congested average end-to-end delay of LLCP. As the node number increases, node density increases, but the number of clusters remains almost unchanged, as shown in Figure 4. Consequently, the node number per cluster increases. When the node number exceeds 200, the intra-cluster load surpasses the upper limit of the intra-cluster information transmission capacity, causing congestion. This prevents timely information transmission, leading to a sharp increase in the average end-to-end delay.

In our proposed LLCP, the node number per cluster is optimized based on node load and location information to prevent congestion. Although this increases the number of clusters, as shown in Figure 4, it ensures that the network complexity is minimized while avoiding congestion. Therefore, the average end-to-end delay remains nearly constant.

As a conclusion, LLCP optimizes the number of cluster members based on node load and location, thereby preventing congestion while minimizing network complexity. This optimization enhances network performance.

4.2. Performance under Different Packet Sizes

Figure 6 and Figure 7 demonstrate the performance in terms of the average cluster number and the average end-to-end delay under different packet sizes. The simulation parameters are chosen as follows: the node number is 50 and the communication range is 700 m. The simulation results indicate that our proposed LLCP achieves the lowest average end-to-end delay, and maximizing the reduction of network complexity while avoiding congestion.

Packet size primarily affects the intra-cluster load. With increasing packet size and a constant number of cluster members, the intra-cluster load gradually increases. Figure 6 presents the performance of average cluster number. In DEKCS, the number of clusters remains unchanged, while in LLCP, it increases with the packet size. DEKCS clusters based on the communication range, so with a constant node number and network range, the average cluster number remains steady. However, as the packet size increases, exceeding 175 bytes, the intra-cluster load surpasses the upper limit of the intra-cluster information transmission capacity. This leads to congestion, resulting in a sharp increase in average end-to-end delay, as shown in Figure 7.

For LLCP, optimization of cluster member numbers based on load maximizes network simplification while avoiding congestion. As the packet size increases, the load per cluster member rises. With the intra-cluster transmission capacity limit remaining nearly constant, congestion avoidance necessitates reducing the number of cluster members. As the average number of cluster members decreases, the average number of clusters increases with the packet size. Therefore, congestion within clusters is avoided, maintaining consistently low average end-to-end delay, as depicted in Figure 7. When the packet size is less than 75 bytes, even if all nodes within the communication range join the current cluster, congestion does not occur, resulting in the same number of clusters in DEKCS and LLCP.

In conclusion, optimizing cluster member numbers based on node load effectively minimizes network complexity while avoiding congestion, thereby enhancing network performance.

4.3. Performance under Different Communication Ranges

Figure 8 and Figure 9 illustrate the performance of average cluster number and average end-to-end delay under different communication ranges. The simulation parameters are as follows: 500 nodes with a packet size of 125 bytes. Simulation results demonstrate that our proposed LLCP achieves the lowest average end-to-end delay, maximizing the reduction of network complexity while avoiding congestion.

The communication range primarily influences the number of neighboring node, thereby affecting the number of cluster members based on different clustering strategies. A larger communication range allows for a greater number of selectable cluster members. Figure 8 demonstrates the performance of average cluster number. DEKCS clusters based on the communication range, where nodes within the communication range are grouped into the same cluster. Consequently, as the communication range increases, the node number within each cluster increases and the number of clusters decreases. However, as the number of cluster members increases, congestion occurs when the intra-cluster load exceeds the upper limit of the intra-cluster information transmission capacity, leading to a sharp increase in end-to-end delay, as depicted in Figure 9.

LLCP, on the other hand, optimizes cluster member selection based on node load and location. As the communication range increases, the number of clusters initially decreases and then remains almost constant. This is mainly because when the intra-cluster load reaches its limit, excessive nodes are removed to prevent congestion. When the communication range is small, there are fewer cluster members, resulting in more clusters. However, as the number of cluster members reaches its limit, even with continued increases in the communication range, the number of clusters does not increase. This trade-off between reducing network complexity and achieving the lowest end-to-end delay performance is depicted in Figure 9. Despite the continuous increase in the communication range, the average end-to-end delay remains almost unchanged and very low.

5. Conclusions

Congestion occurs when the intra-cluster load is greater than the upper limit of the intra-cluster information transmission capacity, which leads to a dramatic deterioration of network performance despite the reduction of network complexity. We propose LLCP to avoid congestion. By optimizing the number of cluster members based on node load and location, we aim to maximize the reduction of network complexity while avoiding congestion. First, a node load and location-based optimization mechanism is proposed to maximize the number of cluster members while avoiding congestion. Then, a node degree and location-based cluster member selection mechanism is proposed to remove redundant nodes and select optimal cluster members. Finally, a priority-based clustering mechanism is proposed. The node clustering order is adjusted based on the clustering priority to maximize the reduction of network complexity. Compared to clustering protocols such as DEKCS, which do not consider node load and position, our proposed LLCP aims to approach the upper limit of the intra-cluster information transmission capacity as closely as possible, while ensuring that the intra-cluster load does not exceed the upper limit of the intra-cluster information transmission capacity. As a conclusion, LLCP maximally reduces the network complexity while avoiding congestion by optimizing the number of cluster members, selecting the optimal cluster members, and adjusting clustering priorities. Simulation results also show that our proposed LLCP minimizes the network complexity while avoiding congestion.