80  Data Aggregation in WSN Routing

In 60 Seconds

In-network data aggregation reduces WSN traffic by 70-95% by combining readings at intermediate nodes before forwarding to the sink. Aggregation function choice matters: MIN/MAX preserve extremes for alarm detection, AVG reduces noise for environmental monitoring, and COUNT supports density estimation. Tree-structured aggregation is optimal for periodic reporting (latency = O(depth)), while cluster-based aggregation suits event-driven applications where spatial correlation enables 10:1 compression ratios within cluster radius.

80.1 Learning Objectives

By the end of this chapter, you will be able to:

• Apply Data Aggregation: Implement in-network data processing to reduce communication overhead
• Select Aggregation Functions: Choose appropriate functions (MIN, MAX, AVG, SUM) for different applications
• Evaluate Aggregation Metrics: Measure accuracy, completeness, latency, and message overhead
• Design Aggregation Trees: Structure networks for efficient data combination

For Beginners: Data Aggregation in WSN Routing

Imagine 100 weather sensors scattered across a field, each measuring temperature every minute. Without aggregation, every sensor independently sends its reading all the way to the base station – 100 radio transmissions every minute. Data aggregation changes this: sensors first report to a nearby “cluster head” node, which combines all the readings into a single summary packet (for example, the average temperature) and sends just one transmission to the base station. This reduces 100 transmissions down to 10 or fewer, dramatically saving battery energy and reducing radio congestion.

80.2 Prerequisites

Before diving into this chapter, you should be familiar with:

• Directed Diffusion: Understanding data-centric routing and gradient-based forwarding
• WSN Routing Challenges: Why energy efficiency is critical in sensor networks
• Wireless Sensor Networks: WSN architecture and multi-hop communication

MVU: Minimum Viable Understanding

Core concept: Data aggregation combines readings from multiple sensors at intermediate nodes before forwarding to the sink, reducing transmissions by 60-95% and dramatically extending network lifetime.

Why it matters: Without aggregation, every sensor sends its own packet to the sink – in a 100-node network, that is 100 long-distance transmissions per round. With aggregation, cluster heads collect, summarize, and send just one packet each, saving up to 95% of energy.

Key takeaway: Choose your aggregation function carefully – AVERAGE for monitoring, MAX for fire detection, SUM for rainfall measurement. Over-aggregating critical data can hide anomalies that individual readings would catch.

For Kids: Meet the Sensor Squad!

Data aggregation is like making a class summary instead of everyone writing their own report!

80.2.1 The Sensor Squad Adventure: The Big Report

Farmer Jones needed a weather report from ALL the sensors on the farm. But there were 20 sensors – if each one sent its own message, poor Bella the Button by the farmhouse would have to listen to 20 messages!

“I have a better idea!” said Sammy the Temperature Sensor. “Let me be the group leader for my area. Everyone in my group tells ME their temperature, and I will send Farmer Jones just ONE message: ‘Average temperature in the pond area is 22 degrees!’”

Lila did the same for the orchard, and Max did the same for the barn. Instead of 20 messages traveling all the way to the farmhouse, only 3 short summaries were sent!

“But wait,” said Bella. “What if one sensor near the pond detected a fire? If you just send the AVERAGE temperature, the fire gets hidden!”

Sammy thought hard. “You are right! For fire detection, I should send the MAXIMUM temperature, not the average. That way, even one hot reading triggers the alarm!”

80.2.2 Key Words for Kids

Word	What It Means
Data aggregation	Combining many messages into one summary (like a class president reporting for the whole class)
Cluster head	The group leader who collects and summarizes everyone’s data
AVERAGE	Adding up all values and dividing by the count – good for general monitoring
MAX	Keeping only the biggest value – essential for detecting emergencies like fires

Key Concepts

• Routing Protocol: Algorithm determining the path a packet takes through the multi-hop WSN to reach the sink
• Convergecast: N-to-1 routing pattern where all sensor data flows toward a single sink along a tree structure
• Routing Table: Per-node data structure mapping destination addresses to next-hop neighbors
• Energy-Aware Routing: Protocol selecting paths based on node residual energy to balance consumption and maximize lifetime
• Link Quality Indicator (LQI): Metric quantifying the reliability of a wireless link — higher LQI means more reliable packet delivery
• Routing Tree: Spanning tree structure rooted at the sink used by hierarchical routing protocols
• Multi-path Routing: Maintaining multiple disjoint paths to improve reliability and enable load balancing

80.3 Introduction

Figure 80.1: Data aggregation in sensor networks reducing traffic through in-network processing

Figure 80.2: Example of data aggregation showing multiple sensor readings combined at intermediate nodes

Data aggregation combines data from multiple sensors to reduce the number of transmissions, saving energy and bandwidth. This is one of the most effective energy-saving techniques in WSN routing.

Putting Numbers to It

Quantifying aggregation savings in a 100-node agricultural WSN: Each sensor reports temperature every 10 minutes. Without aggregation, all 100 sensors send individual packets (40 bytes each) to the sink over an average 4-hop path.

Without aggregation: \[\text{Total transmissions} = 100 \text{ sensors} \times 4 \text{ hops} = 400 \text{ transmissions per round}\]

With tree-based aggregation (10 branches, 10 nodes per branch): Each branch aggregates 10 readings into 1 packet (40 bytes payload + 10 bytes aggregate metadata = 50 bytes). Branch heads transmit aggregated packets over average 2 hops to sink.

With aggregation: \[\text{Total transmissions} = (100 \times 1) + (10 \times 2) = 120 \text{ transmissions per round}\]

Energy savings: At 50 µJ per transmission: \((400 - 120) \times 50 \text{ µJ} = 14{,}000 \text{ µJ} = 14 \text{ mJ per round}\). With 6 rounds/hour: \(14 \text{ mJ} \times 6 \times 24 = 2{,}016 \text{ mJ/day} = 2.02 \text{ J/day}\) saved. Without aggregation: \(400 \times 50\,\mu\text{J} \times 6 \times 24 = 2{,}880 \text{ mJ/day} = 2.88 \text{ J/day}\). With aggregation: \(120 \times 50\,\mu\text{J} \times 6 \times 24 = 864 \text{ mJ/day} = 0.864 \text{ J/day}\). For a node with 10,000 J battery: lifetime without aggregation = \(10{,}000 / 2.88 \approx\) 9.5 years, with aggregation = \(10{,}000 / 0.864 \approx\) 32 years (limited by battery shelf life after ~10 years).

---

80.4 Aggregation Benefits

80.4.1 Energy Savings

• Fewer transmissions = less energy consumed
• Particularly effective in dense networks
• Can extend network lifetime by 70-90%

80.4.2 Bandwidth Efficiency

• Reduces network congestion
• Lowers collision probability
• Reduces channel occupancy (though per-hop latency may increase due to aggregation wait time)

80.4.3 Data Quality

• Averaging reduces noise
• Outlier detection and filtering
• Temporal and spatial correlation exploitation

Figure 80.3: Data aggregation architecture showing 100 sensors organized into 5 aggregation groups, reducing transmission from 100 to 5 messages at sink

---

80.5 Aggregation Functions

80.5.1 Simple Aggregation

Function	Description	Use Case
MIN	Minimum value	Lowest temperature, closest distance
MAX	Maximum value	Peak temperature, farthest reading
SUM	Total of all values	Total rainfall, cumulative count
COUNT	Number of readings	Active nodes, detection events
AVERAGE	Mean value	Average temperature across region

80.5.2 Statistical Aggregation

Function	Description	Use Case
MEDIAN	Middle value	Robust central tendency
VARIANCE	Spread of values	Variability assessment
STANDARD DEVIATION	Measure of dispersion	Quality control bounds
HISTOGRAM	Distribution of values	Pattern analysis

80.5.3 Duplicate-Sensitive Functions

Function	Description	Use Case
DISTINCT COUNT	Count unique values	Unique detection events
SET UNION	Combine unique elements	Aggregate unique IDs

Putting Numbers to It

Calculating completeness vs. latency trade-off: A cluster head waits for readings from 20 member nodes before aggregating. Packet loss rate is 5% (PDR = 0.95).

Probability all 20 arrive: \(P(\text{complete}) = 0.95^{20} = 0.358\) (35.8%)

Expected number of arrivals: \(E[\text{arrivals}] = 20 \times 0.95 = 19\) nodes

The cluster head faces a choice: (1) Wait indefinitely until all 20 arrive (average wait time → ∞ if packet permanently lost), or (2) Set timeout at 100 ms and aggregate whatever arrived.

With 100 ms timeout: Assume packet transmission time is 5 ms. Probability a node’s packet arrives within 100 ms = 0.95. Expected completeness = 95%, aggregate represents 19 of 20 nodes. Average temperature error from missing 1 node: \(\Delta T = \frac{|T_{\text{missing}} - T_{\text{avg}}|}{n} \approx \frac{|25 - 22|}{20} =\) 0.15°C – acceptable for most environmental monitoring (±1°C spec). (More precisely, the 19-node average differs from the true 20-node average by \(|T_{\text{missing}} - T_{\text{avg}}|/n\), which equals \(3/20 = 0.15\)°C here.)

Key insight: For aggregation functions like AVERAGE, 95% completeness introduces minimal error (<1%) but dramatically reduces latency from unbounded to 100 ms.

80.5.4 Complex Queries

Function	Description	Use Case
TOP-K	K largest/smallest values	Hot spots, anomalies
THRESHOLD	Values exceeding threshold	Alert generation
EVENT DETECTION	Specific patterns	Intrusion, fire detection

Quick Check: Choosing Aggregation Functions

---

80.6 Aggregation Metrics

80.6.1 1. Accuracy

Difference between aggregated result and true result:

Error = |Aggregated_Value - True_Value| / True_Value

Factors affecting accuracy: - Packet loss (missing readings) - Sensor calibration errors - Temporal misalignment

80.6.2 2. Completeness

Percentage of readings included in aggregate:

Completeness = Readings_Included / Total_Readings

Higher completeness = more representative aggregate. Trade-off with latency (waiting for stragglers).

80.6.3 3. Latency

Time from sensing to sink reception:

• Aggregation introduces delay (waiting for multiple readings)
• Must balance freshness vs. completeness
• Application-dependent requirements

80.6.4 4. Message Overhead

Number of messages transmitted:

• Primary benefit of aggregation
• Measure: messages with vs. without aggregation
• Target: 60-95% reduction typical

---

80.7 Application-Appropriate Aggregation

Pitfall: Over-Aggregating Critical Data

The Mistake: Applying aggressive data aggregation (averaging, compression) uniformly across all sensor data, then missing critical events because anomalies were smoothed away by spatial averaging.

Why It Happens: Aggregation dramatically reduces energy consumption (95% savings possible), so teams maximize it. However, if 1 out of 20 sensors detects a fire while 19 report normal, the cluster average temperature may remain below the alarm threshold.

The Fix: Use aggregation functions appropriate to your application:

• For event detection: Use MAX or ANY-EXCEED-THRESHOLD instead of AVERAGE
• For anomaly detection: Forward individual readings that exceed thresholds
• Dual-path routing: Aggregated summaries for efficiency plus raw anomaly values on separate path
• Threshold-aware aggregation: Cluster heads forward individual readings that exceed critical thresholds, even when aggregating others

Example Decision Matrix:

Application	Recommended Function	Rationale
Fire detection	MAX or THRESHOLD	Single hot spot must trigger alarm
Temperature monitoring	AVERAGE	Spatial average is meaningful
Intruder detection	ANY (boolean OR)	One detection = alert
Rainfall measurement	SUM	Total across region needed
Air quality	AVERAGE with outliers	Average, but flag anomalies

---

80.8 LEACH Clustering Demo

Explore how LEACH (Low-Energy Adaptive Clustering Hierarchy) balances energy consumption through randomized cluster head rotation. Watch energy depletion over multiple rounds and compare with direct transmission.

Interactive: LEACH Clustering Demo

How LEACH Works:

1. Cluster Head Election: Each round, nodes independently decide to become cluster heads (CH) based on probability p. Nodes that were recently CH have lower probability, ensuring rotation.

2. Cluster Formation: Non-CH nodes join the nearest cluster head to minimize transmission distance.

3. Data Aggregation: Members send data to their CH (short-distance, low energy). CHs aggregate data and transmit once to the sink (long-distance, high energy).

4. Energy Balancing: By rotating the CH role, no single node bears the aggregation burden throughout network lifetime.

Key Observations:

• Color gradient shows node energy levels (green=healthy, red=depleted)
• CH markers show current cluster heads and cluster regions
• Energy bars compare LEACH vs. direct transmission
• Run multiple rounds to see how CH role distributes and energy depletes evenly

Energy Comparison:

Routing Method	Energy Profile
Direct Transmission	Nodes near sink deplete fast (hotspot)
Fixed Cluster Heads	CHs die quickly, others survive
LEACH (rotating)	Even depletion across all nodes

Expected Energy Savings:

For a 100-node network with 10 clusters: - Direct: 100 long-distance transmissions - LEACH: 100 short + 10 long transmissions - Savings: 40-60% depending on topology

Pitfall: Fixed Cluster Head Selection

The Mistake: Designating cluster heads based on initial battery levels or geographic position, then having the network partition when all cluster heads die simultaneously while regular nodes still have 70% battery.

Why It Happens: Fixed cluster heads seem logical - “put the strongest nodes in charge.” But cluster heads consume 3-5x more energy than regular nodes due to receiving from members, aggregation, and long-range transmission to the sink. Static assignment concentrates this drain on a few nodes.

The Fix: Implement cluster head rotation as in LEACH:

• Each round, cluster heads are selected probabilistically
• Every node serves approximately equal time as CH over network lifetime
• Consider energy-weighted probability: nodes with more remaining energy have slightly higher CH probability
• Monitor CH energy levels and trigger early rotation if a CH drops below 20% while others have 50%+

---

80.9 Worked Example: LEACH Energy Analysis

Worked Example: LEACH Cluster Head Selection and Energy Analysis

Scenario: A precision agriculture deployment monitors soil moisture across a 500m × 500m vineyard. The WSN uses LEACH protocol with 100 sensor nodes reporting to a base station located at coordinate (250m, 0m) at the vineyard edge.

Given:

Parameter	Value
Total nodes	100
Initial energy per node	2 J (Joules)
Cluster head probability (p)	10% (0.1)
Energy for transmission (E_tx)	50 nJ/bit
Energy for receiving (E_rx)	50 nJ/bit
Energy for data aggregation	5 nJ/bit/signal
Amplifier energy (E_amp)	100 pJ/bit/m^2
Data packet size	4000 bits
Average distance to base station	200 m
Average intra-cluster distance	35 m

Steps:

1. Calculate expected cluster heads per round:
   • Expected CHs = n × p = 100 × 0.1 = 10 cluster heads
   • Average cluster size = 100 / 10 = 10 nodes per cluster (9 members + 1 CH)
2. Calculate energy consumption for a regular node (cluster member):
   • Transmit to CH (short range): E_member = E_tx × k + E_amp × k × d²
   • E_member = (50 nJ/bit × 4000 bits) + (100 pJ/bit/m² × 4000 bits × 35² m²)
   • E_member = 200 µJ + 490 µJ = 690 µJ per round
3. Calculate energy consumption for a cluster head:
   • Receive from 9 members: E_rx_total = 9 × E_rx × k = 9 × 50 nJ/bit × 4000 bits = 1,800 µJ
   • Aggregate 10 signals: E_agg = 10 × 5 nJ/bit/signal × 4000 bits = 200 µJ
   • Transmit to base station (long range): E_tx_bs = E_tx × k + E_amp × k × d²
   • E_tx_bs = (50 nJ/bit × 4000 bits) + (100 pJ/bit/m² × 4000 bits × 200² m²)
   • E_tx_bs = 200 µJ + 16,000 µJ = 16,200 µJ
   • Total CH energy = 1,800 + 200 + 16,200 = 18,200 µJ per round
4. Calculate network energy per round:
   • 90 members × 690 µJ = 62,100 µJ
   • 10 CHs × 18,200 µJ = 182,000 µJ
   • Total network energy = 244,100 µJ = 244.1 mJ per round
5. Estimate network lifetime:
   • Total initial energy = 100 nodes × 2 J = 200 J
   • Rounds until first node dies: ~200 J / 244.1 mJ = ~820 rounds
   • With CH rotation, energy depletes evenly, extending usable lifetime

Result: With LEACH and p=0.1, the network consumes 244.1 mJ per data collection round. Cluster heads consume 26× more energy than members (18,200 µJ vs 690 µJ), which is why rotation is critical. Without rotation, the 10 static CHs would die in ~110 rounds while other nodes retain 94% energy.

Key Insight: The LEACH probability p=0.1 creates 10 clusters optimized for this 100-node network. Increasing p to 0.2 would create 20 smaller clusters with shorter intra-cluster distances (less member energy) but more long-range CH-to-base transmissions (more total CH energy). For deployments where base station distance dominates, lower p values (larger clusters, fewer CHs) are more energy-efficient.

---

80.10 Interactive: LEACH Energy Calculator

Adjust the LEACH parameters below to see how cluster head probability and network size affect energy consumption and network lifetime.

viewof leach_n = Inputs.range([20, 500], {value: 100, step: 10, label: "Number of nodes (n)"})

viewof leach_p = Inputs.range([0.02, 0.30], {value: 0.10, step: 0.01, label: "Cluster head probability (p)"})

viewof leach_e0 = Inputs.range([0.5, 5.0], {value: 2.0, step: 0.1, label: "Initial energy per node (J)"})

viewof leach_d_bs = Inputs.range([50, 500], {value: 200, step: 10, label: "Distance to base station (m)"})

viewof leach_d_cluster = Inputs.range([5, 100], {value: 35, step: 5, label: "Avg intra-cluster distance (m)"})

{
  const k = 4000; // bits per packet
  const E_tx = 50e-9; // J/bit
  const E_rx = 50e-9; // J/bit
  const E_amp = 100e-12; // J/bit/m^2
  const E_agg_per_bit_signal = 5e-9; // J/bit/signal

  const expected_ch = Math.round(leach_n * leach_p);
  const cluster_size = leach_n / expected_ch;
  const members_per_cluster = cluster_size - 1;

  // Member energy: transmit to CH
  const E_member = (E_tx * k) + (E_amp * k * leach_d_cluster * leach_d_cluster);

  // CH energy: receive from members + aggregate + transmit to BS
  const E_rx_total = members_per_cluster * E_rx * k;
  const E_agg = cluster_size * E_agg_per_bit_signal * k;
  const E_tx_bs = (E_tx * k) + (E_amp * k * leach_d_bs * leach_d_bs);
  const E_ch = E_rx_total + E_agg + E_tx_bs;

  const total_members = leach_n - expected_ch;
  const E_total_round = (total_members * E_member + expected_ch * E_ch) * 1e6; // µJ
  const E_total_round_mJ = E_total_round / 1000;

  const total_energy = leach_n * leach_e0 * 1000; // mJ
  const lifetime_rounds = Math.round(total_energy / E_total_round_mJ);

  const ratio = E_ch / E_member;

  // Without rotation: static CH lifetime (E_ch in J, E0 in J)
  const static_ch_lifetime = Math.round(leach_e0 / E_ch);

  return html`<div style="background: var(--bs-light, #f8f9fa); padding: 1rem; border-radius: 8px; border-left: 4px solid #16A085; margin-top: 0.5rem;">
  <p><strong>Expected cluster heads per round:</strong> ${expected_ch} (avg cluster size: ${cluster_size.toFixed(1)} nodes)</p>
  <p><strong>Member energy per round:</strong> ${(E_member * 1e6).toFixed(1)} µJ</p>
  <p><strong>Cluster head energy per round:</strong> ${(E_ch * 1e6).toFixed(0)} µJ</p>
  <p><strong>CH/Member energy ratio:</strong> ${ratio.toFixed(1)}x (why rotation matters)</p>
  <p><strong>Total network energy per round:</strong> ${E_total_round_mJ.toFixed(1)} mJ</p>
  <p><strong>Network lifetime (rotating CHs):</strong> ~${lifetime_rounds} rounds</p>
  <p><strong>Static CH lifetime (no rotation):</strong> ~${static_ch_lifetime} rounds before CHs die</p>
  <p style="color: #E67E22;"><strong>Rotation benefit:</strong> ${Math.round(lifetime_rounds / static_ch_lifetime)}x longer network lifetime with CH rotation</p>
  </div>`;
}

---

80.11 Knowledge Check

Quiz: Data Aggregation

---

Interactive: LEACH Cluster Head Rotation Animation

Interactive: WSN Data Aggregation Tree Animation

80.12 Deployment Economics: Aggregation Impact on Network Cost

Cost-Benefit Analysis: Data Aggregation in Large-Scale WSN

Scenario: A water utility monitors water quality across a 200 km pipeline network with 500 sensor nodes measuring pH, turbidity, chlorine, and temperature every 5 minutes. Compare network operating costs with and without data aggregation.

Network Configuration:

Parameter	Value
Total sensor nodes	500
Readings per node per hour	48 (4 parameters x 12 samples/hour)
Packet size	32 bytes per reading
Cluster size	10 nodes per cluster (50 clusters)
Gateway backhaul	Cellular (NB-IoT at $0.50 per MB)
Battery	19,000 mAh lithium primary ($42 each)
TX energy	50 uJ per byte
Maintenance visit cost	$180 (truck roll + technician)

Without Aggregation (Raw Forwarding):

• Packets to gateway per hour: 500 nodes x 48 readings = 24,000 packets
• Data volume per hour: 24,000 x 32 bytes = 768 KB
• Monthly cellular cost: 768 KB x 24 x 30 / 1,000 = 552 MB = $276/month
• Hotspot node relay load: ~240 packets/hour (nodes adjacent to gateway)
• Hotspot battery life: 4.2 months (relay energy dominates)
• Annual battery replacement: 120 hotspot nodes x 3 replacements x $42 = $15,120 in batteries
• Annual maintenance visits: 360 visits x $180 = $64,800 in labor

With LEACH-Style Aggregation (AVG + MAX per cluster):

• Each cluster head aggregates 10 nodes’ readings into 1 summary packet (average + max per parameter)
• Packets to gateway per hour: 50 clusters x 12 summaries = 600 packets (96% reduction)
• Data volume per hour: 600 x 64 bytes = 38.4 KB
• Monthly cellular cost: 38.4 KB x 24 x 30 / 1,000 = 27.6 MB = $13.80/month
• Rotating cluster heads: energy distributed evenly
• Battery life (all nodes): 3.8 years (uniform depletion)
• Annual battery replacement: 0 (all nodes survive year 1-3)
• Annual maintenance visits: 10 visits (calibration only) x $180 = $1,800

5-Year Total Cost Comparison:

Cost Category	Without Aggregation	With Aggregation	Savings
Cellular backhaul	$16,560	$828	95%
Battery replacement	$75,600	$21,000 (year 4 bulk)	72%
Maintenance labor	$324,000	$9,000	97%
5-year total	$416,160	$30,828	93%

Key Insight: Data aggregation’s primary economic benefit is not the cellular data savings (though 95% reduction is significant). The dominant cost driver is maintenance labor – truck rolls to replace batteries in hotspot nodes. By eliminating hotspots through aggregation and cluster head rotation, the network transforms from a maintenance-intensive system requiring 360 annual visits to a deploy-and-forget system requiring only 10 calibration visits per year.

Common Pitfalls

1. Building Routing Tables Without Energy Awareness

Shortest-hop routing concentrates relay load on nodes near the sink, depleting them 10-100× faster than edge nodes. Always incorporate residual energy into route metric (e.g., ETX × energy factor) to balance consumption and prevent premature network partitioning.

2. Forgetting to Handle Routing Table Staleness

WSN topology changes as nodes die or move — routing tables become stale within hours in dynamic deployments. Implement periodic route discovery with a timeout proportional to expected node lifetime, and use link-quality metrics that decay when no recent transmissions are observed.

3. Using Flooding for Data Collection in Dense Networks

Flooding generates O(n²) messages in a 100-node network — a single data collection round produces 10,000 transmissions. Use directed diffusion or tree-based convergecast to reduce collection overhead to O(n) messages.

🏷️ Label the Diagram

Code Challenge

80.13 Summary

This chapter explored data aggregation as a core technique for energy-efficient WSN routing:

Key Takeaways:

1. Dramatic Energy Savings: Aggregation reduces transmissions by 60-95%, extending network lifetime from months to years
2. Function Selection Matters: Use AVERAGE for monitoring, MAX for fire detection, SUM for cumulative measurements, and THRESHOLD for anomaly alerts
3. Aggregation Metrics: Evaluate aggregation by accuracy, completeness, latency, and message overhead – balancing these trade-offs depends on your application
4. LEACH Rotation: Cluster head rotation is critical because CHs consume 26x more energy than regular members; fixed CHs die in ~110 rounds vs ~820 with rotation
5. Avoid Over-Aggregation: Never average away critical anomalies; use dual-path routing or threshold-aware aggregation for safety-critical applications

---

Match Aggregation Concepts to Their Descriptions

Order the Data Aggregation Design Steps

80.14 What’s Next?

Topic	Chapter	Description
Link Quality Routing	WSN Routing: Link Quality	RSSI, WMEWMA, and MIN-T metrics for reliable path selection
Directed Diffusion	WSN Routing: Directed Diffusion	Data-centric routing with interests and gradients
Trickle Algorithm	WSN Routing: Trickle Algorithm	Network reprogramming with polite gossip protocol
Labs and Games	WSN Routing: Labs and Games	Hands-on practice and interactive simulations