77  WSN Routing Challenges

In 60 Seconds

Traditional routing protocols (OSPF, BGP, RIP) fail in WSNs because they are address-centric and ignore energy constraints, while WSNs need data-centric, energy-aware routing supporting many-to-one convergecast traffic. Using traditional routing drains batteries unevenly, creates hotspots near the sink, and wastes bandwidth by ignoring data aggregation – potentially cutting network lifetime from years to weeks.

77.1 Learning Objectives

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

• Explain WSN Routing Failures: Articulate why traditional routing protocols (OSPF, BGP, RIP) fail in sensor networks
• Contrast Routing Paradigms: Distinguish address-centric from data-centric routing approaches with quantified trade-offs
• Evaluate Routing Requirements: Assess energy efficiency, scalability, and robustness requirements for WSN routing protocols

For Beginners: WSN Routing Challenges

Routing in wireless sensor networks determines how data finds its way from sensors to the collection point. Think of water flowing downhill through a network of channels – routing protocols create efficient pathways for data, choosing routes that conserve battery power while ensuring messages arrive reliably.

77.2 Prerequisites

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

• WSN Routing Introduction: Understanding the fundamental differences between WSN and traditional routing
• Wireless Sensor Networks: WSN architecture and multi-hop communication patterns

MVU: Minimum Viable Understanding

Core concept: Traditional routing protocols (OSPF, BGP, RIP) fail in WSNs because they are address-centric and ignore energy constraints, while WSNs need data-centric, energy-aware routing that supports many-to-one traffic patterns.

Why it matters: Using traditional routing in a sensor network drains batteries unevenly, creates energy hotspots near the sink, and wastes bandwidth by ignoring data aggregation opportunities – potentially cutting network lifetime from years to weeks.

Key takeaway: WSN routing must optimize for energy efficiency (not throughput), support in-network data aggregation, scale to thousands of nodes, and tolerate frequent node failures.

For Kids: Meet the Sensor Squad!

Why do sensors need special directions to send messages? Because the old rules do not work for tiny battery-powered friends!

77.2.1 The Sensor Squad Adventure: The Wrong Directions

One day, Sammy the Temperature Sensor got a set of directions from the Big Internet Router. “Just follow the shortest road to the farmhouse,” it said. But Sammy had a problem.

“The shortest road goes straight through the muddy swamp!” said Sammy. “I will use up all my battery jumping through the mud.”

Lila the Light Sensor had a better idea. “Let us NOT follow the shortest road. Let us find the road where everyone shares the work equally. That way, nobody gets too tired!”

Max the Motion Detector agreed. “And instead of each of us sending our own message, let us combine them! I can tell Farmer Jones: ‘Sammy says it is hot, Lila says it is bright, and I detected movement’ – all in ONE message instead of three!”

“That is called data aggregation!” said Bella the Button. “It saves so much energy because fewer messages need to travel!”

77.2.2 Key Words for Kids

Word	What It Means
Energy hotspot	A sensor that gets tired really fast because too many messages pass through it – like the kid who always has to pass every note in class
Many-to-one	All sensors send to ONE place (like everyone turning in homework to the teacher)
Data aggregation	Combining many messages into one (like a class summary instead of 30 individual reports)
Data-centric	Caring about WHAT a message says, not WHO sent it

Key Concepts

• Address-Centric Routing: Traditional routing based on destination IP addresses
• Data-Centric Routing: Routing based on data content and attributes
• Energy Hotspots: Nodes that deplete faster due to forwarding traffic from many sources
• Many-to-One Traffic: Communication pattern where all sensors report to a central sink
• In-Network Processing: Processing data within the network to reduce transmissions

77.3 Why Traditional Routing Fails in WSNs

Traditional network routing protocols like OSPF, BGP, and RIP were designed for wired networks with fundamentally different characteristics. When applied to WSNs, they fail for several critical reasons.

77.3.1 1. Address-Centric vs Data-Centric

Traditional: Route packets to specific IP addresses. The network cares about where data goes, not what it contains.

WSN: Route data based on content (“temperature > 30°C”). Node addresses may not be globally unique or even available. The network cares about what data contains, not necessarily who sent it.

Figure 77.1: Comparison of traditional routing (address-centric, peer-to-peer, performance-focused) vs WSN routing (data-centric, many-to-one, energy-focused)

77.3.2 2. Communication Pattern

Traditional: Peer-to-peer communication. Any node can communicate with any other node.

WSN: Many-to-one (sensors to sink), one-to-many (sink to sensors). Rarely sensor-to-sensor communication. This asymmetric pattern creates unique challenges.

77.3.3 3. Energy Constraints

Traditional: Minimize latency, maximize throughput. Routers are mains-powered with abundant resources.

WSN: Minimize energy consumption to extend lifetime. Sensors run on batteries for years. The shortest path may not be energy-optimal if it creates energy hotspots.

77.3.4 4. Scale and Density

Traditional: Hundreds to thousands of nodes with relatively sparse connectivity.

WSN: Potentially thousands to millions of nodes with high density. This density enables in-network processing but creates routing table overhead challenges.

77.3.5 5. Node Failures

Traditional: Relatively rare failures trigger rerouting procedures.

WSN: Common failures due to energy depletion. Nodes can’t always be replaced. Routing must be robust to frequent topology changes.

---

77.4 Routing Requirements in WSNs

Given these challenges, WSN routing protocols must meet specific requirements:

77.4.1 Energy Efficiency

• Minimize transmission energy: Radio transmission dominates energy consumption
• Balance load across nodes: Avoid creating energy hotspots near the sink
• Consider residual energy: Route through nodes with higher remaining battery

Putting Numbers to It

Hotspot Energy Depletion in Many-to-One Traffic

Consider a 7-ring agricultural WSN with 100 nodes (radial deployment, 1 sink at center):

Node distribution by ring distance:

• Ring 1 (closest to sink): 4 nodes
• Ring 2-7 (further rings): 96 nodes evenly distributed

Traffic pattern (all sensors → sink):

• Each sensor: 1 packet/10 min = 144 packets/day
• Average path length: 3.5 hops

Energy consumption per node:

• Transmit own data: 144 packets × 20 mJ = 2.88 J/day
• Forward others’ traffic (ring 1 nodes): \(\frac{96 \text{ nodes} \times 144}{4 \text{ ring-1 nodes}} = 3,456\) packets forwarded/day/node
• Ring 1 forwarding energy: \(3,456 \times 20 = 69,120\) mJ = 69.1 J/day
• Total ring 1 energy: \(2.88 + 69.1 = 72\) J/day

Battery lifetime comparison:

• Edge nodes (ring 7, no forwarding): \(\frac{10,800 \text{ J}}{2.88 \text{ J/day}} = 3,750\) days (10 years)
• Hotspot nodes (ring 1): \(\frac{10,800 \text{ J}}{72 \text{ J/day}} = 150\) days (5 months)

Network death: When ring 1 dies at 150 days, 96 nodes with 96% remaining battery become disconnected. Load balancing via multi-sink or mobile sink is essential.

77.5 WSN Hotspot Lifetime Calculator

Explore how the hotspot problem affects network lifetime based on ring topology and traffic rate.

viewof total_nodes_h = Inputs.range([20, 500], {value: 100, step: 10, label: "Total sensor nodes"})

viewof ring1_fraction = Inputs.range([0.02, 0.3], {value: 0.04, step: 0.01, label: "Ring 1 nodes (fraction of total)"})

viewof packets_per_day = Inputs.range([10, 1000], {value: 144, step: 10, label: "Packets per node per day"})

viewof battery_j = Inputs.range([1000, 50000], {value: 10800, step: 1000, label: "Battery energy (J)"})

{
  const ring1_nodes = Math.round(total_nodes_h * ring1_fraction);
  const outer_nodes = total_nodes_h - ring1_nodes;
  const tx_energy_mJ = 20; // mJ per transmission

  // Edge node: only transmits own data
  const edge_daily_J = packets_per_day * tx_energy_mJ / 1000;
  const edge_life_days = battery_j / edge_daily_J;

  // Ring 1 node: transmits own data + relays all outer traffic
  const relay_per_ring1 = (outer_nodes * packets_per_day) / ring1_nodes;
  const ring1_daily_J = (packets_per_day + relay_per_ring1) * tx_energy_mJ / 1000;
  const ring1_life_days = battery_j / ring1_daily_J;

  const ratio = edge_life_days / ring1_life_days;

  return html`<div style="background: var(--bs-light, #f8f9fa); padding: 1rem; border-radius: 8px; border-left: 4px solid #E74C3C; margin-top: 0.5rem;">
    <p><strong>Hotspot Analysis</strong> (${ring1_nodes} ring-1 nodes, ${outer_nodes} outer nodes)</p>
    <p>Relay burden per ring-1 node: <strong>${relay_per_ring1.toFixed(0)} packets/day</strong></p>
    <table style="width:100%;border-collapse:collapse;">
      <thead><tr style="background:#2C3E50;color:white;"><th style="padding:6px 8px;text-align:left;">Node Type</th><th style="padding:6px 8px;text-align:right;">Daily Energy</th><th style="padding:6px 8px;text-align:right;">Lifetime</th></tr></thead>
      <tbody>
        <tr><td style="padding:4px 8px;">Edge node (outer ring)</td><td style="padding:4px 8px;text-align:right;">${edge_daily_J.toFixed(2)} J/day</td><td style="padding:4px 8px;text-align:right;color:#16A085;">${(edge_life_days/365).toFixed(1)} years</td></tr>
        <tr style="background:#f0f0f0;"><td style="padding:4px 8px;">Hotspot node (ring 1)</td><td style="padding:4px 8px;text-align:right;">${ring1_daily_J.toFixed(2)} J/day</td><td style="padding:4px 8px;text-align:right;color:#E74C3C;">${ring1_life_days.toFixed(0)} days</td></tr>
      </tbody>
    </table>
    <p style="margin-top:0.5rem;color:#E74C3C;font-weight:bold;">Network dies at ${ring1_life_days.toFixed(0)} days — edge nodes still have ${((1 - ring1_life_days/edge_life_days)*100).toFixed(0)}% battery remaining! (${ratio.toFixed(0)}× disparity)</p>
  </div>`
}

Quick Check: Energy Hotspot Impact

77.5.1 Scalability

• Handle large numbers of nodes: Protocols must scale to thousands of nodes
• Localized algorithms preferred: Avoid global state that requires flooding
• Avoid flooding where possible: Use directed or hierarchical approaches

77.5.2 Data Aggregation

• Combine data from multiple sensors: Reduce redundant transmissions
• In-network processing: Aggregate before forwarding to reduce traffic
• Maintain data accuracy: Balance compression with information preservation

77.5.3 Robustness

• Adapt to node failures: Continue operation when nodes die
• Handle dynamic topology changes: Accommodate node mobility and failures
• Graceful degradation: Maintain partial functionality under stress

77.5.4 Quality of Service

• Latency bounds for time-critical applications: Fire alarms, industrial safety
• Reliability for critical data: Guaranteed delivery for important events
• Bandwidth allocation: Fair resource distribution

---

77.6 Illustrative Examples

LEACH Clustering Protocol

Figure 77.2: LEACH hierarchical clustering protocol showing dynamic cluster head selection, intra-cluster data aggregation, and energy-balanced multi-hop communication to the base station.

Interest Propagation in Directed Diffusion

Figure 77.3: Interest propagation in Directed Diffusion routing: the sink broadcasts interest queries that flood the network, establishing gradient paths along which matching sensor data flows back toward the sink.

Epidemic Routing

Figure 77.4: Epidemic routing in delay-tolerant sensor networks: messages replicate opportunistically when nodes meet, spreading through the network like a disease until reaching the destination.

---

77.7 Knowledge Check

Test your understanding of WSN routing challenges.

Test Your Understanding

Question 1: A temperature monitoring WSN has 100 sensors in a 100m x 100m area. Without aggregation, all 100 sensors send readings to the sink every minute (100 transmissions). With tree-based aggregation using 5 intermediate aggregation points, how many total transmissions occur?

1. 100 transmissions - same as without aggregation since all data must reach the sink
2. 20 transmissions - dramatic reduction through aggressive compression
3. 50 transmissions - approximately half due to aggregation benefits
4. ~105 transmissions - leaves to aggregators (~100) + aggregators to sink (5)

Answer

d) ~105 transmissions. Tree-based aggregation: 100 sensors transmit to 5 aggregators (100 transmissions), then 5 aggregators transmit summaries to sink (5 transmissions). Total = 105. The key energy savings come from replacing 95 long-distance transmissions with short-distance local ones – yielding ~70% energy savings despite a similar transmission count.

Question 2: Which of the following is the PRIMARY reason traditional routing protocols like OSPF fail in WSNs?

1. WSN radios use different physical layer modulation incompatible with OSPF
2. OSPF requires a centralized controller that WSNs cannot provide
3. OSPF’s address-centric design, global state requirements, and performance-first optimization ignore WSN energy and scale constraints
4. OSPF cannot handle wireless communication and only works over wired links

Answer

c) OSPF’s address-centric design, global state requirements, and performance-first optimization ignore WSN energy and scale constraints. OSPF maintains a full topology database (too large for sensor RAM), floods link-state advertisements (high energy cost), uses Dijkstra’s algorithm (expensive for constrained CPUs), and optimizes for throughput/latency rather than energy. WSNs need data-centric, energy-aware, localized protocols.

Question 3: In WSN routing, what is an “energy hotspot” and why does it matter?

1. A node with the highest processing power that attracts more traffic
2. A node near the sink that depletes faster because it forwards traffic from many sources
3. A node that overheats due to excessive radio transmission power
4. A geographic area with poor wireless signal coverage

Answer

b) A node near the sink that depletes faster because it forwards traffic from many sources. In many-to-one WSN traffic, nodes closer to the sink relay data from many source nodes, causing them to consume battery much faster than peripheral nodes. When these relay nodes die, the network partitions, even though distant nodes still have plenty of energy remaining. This is why load-balancing and hierarchical routing are critical.

---

77.8 Common Pitfalls

Pitfall: Running Data Aggregation Without Time Synchronization

The Mistake: A cluster head aggregates readings from 10 nodes and computes the spatial average. But node clocks differ by 2-8 seconds, so some readings are from the current minute while others are stale. The “aggregated” result mixes temporally inconsistent data, producing meaningless averages.

Why It Happens: Developers focus on spatial aggregation (combining data from nearby nodes) but ignore temporal alignment. Without network-wide time synchronization, each node’s timestamp reflects its local clock. When phenomena change rapidly (temperature rising 2°C/minute during fire), a 5-second timing error introduces 0.17°C measurement error - compounding across aggregated nodes.

The Fix: Implement time synchronization before enabling data aggregation:

• Synchronization protocol: Deploy FTSP (Flooding Time Synchronization Protocol) or TPSN achieving <1 ms accuracy across multi-hop networks
• Sync frequency: Resynchronize every 30-60 seconds for µs-level accuracy, every 5-10 minutes for ms-level (sufficient for most environmental monitoring)
• Aggregation windows: Define explicit time windows for aggregation (e.g., “aggregate all readings with timestamp 10:00:00-10:00:05”). Discard readings outside the window rather than mixing temporal epochs
• Staleness threshold: Set maximum data age for aggregation (e.g., 10 seconds). If node reading is older than threshold, request fresh data or exclude from aggregation
• Timestamp format: Use network-synchronized epoch time, not local elapsed time. Include timestamp in every packet: {node_id: 5, value: 21.3, timestamp: 1704067200123}

Pitfall: Using Hop Count Instead of Link Quality for Route Selection

The Mistake: The routing protocol selects a 2-hop path over a 3-hop path because fewer hops means less energy. But the 2-hop path has 60% packet delivery ratio per link, requiring 2.8 retransmissions per hop on average. The “efficient” route wastes 3x more energy than the longer but reliable path.

Why It Happens: Traditional routing metrics (hop count) assume all links are equal. In WSNs, link quality varies dramatically: a link might work 95% of the time at 10 meters but only 30% at 25 meters. The infamous “gray zone” (intermediate distances) has highly variable, often poor link quality that hop-count metrics ignore.

The Fix: Use Expected Transmission Count (ETX) or link-quality metrics instead of hop count:

• ETX calculation: ETX = 1 / (forward_delivery × reverse_delivery). For a link with 80% forward and 90% reverse delivery: ETX = 1/(0.8×0.9) = 1.39 expected transmissions
• Path comparison:
  • Path A (2 hops, poor links): ETX = 1/(0.6×0.6) + 1/(0.6×0.6) = 2.78 + 2.78 = 5.56 total
  • Path B (3 hops, good links): ETX = 1/(0.95×0.95) + 1/(0.95×0.95) + 1/(0.95×0.95) = 1.11 × 3 = 3.33 total
  • Path B saves 40% energy despite being longer!
• Link quality estimation: Sample at least 20-50 packets over 5+ minutes before calculating stable ETX. Use EWMA smoothing: ETX_new = α × ETX_sample + (1-α) × ETX_old where α = 0.1 to 0.25 gives stable estimates weighted toward history.
• Gray zone avoidance: If measured PRR is between 10-90%, consider the link unreliable. Prefer links with PRR > 90% or < 10% (clearly good or clearly avoid)

---

77.9 Routing Protocol Selection Guide for Common IoT Deployments

Choosing the wrong routing protocol wastes energy, reduces network lifetime, and degrades data delivery. This decision framework maps deployment characteristics to protocol families.

Deployment Type	Traffic Pattern	Mobility	Recommended Protocol Family	Why
Agriculture (soil sensors)	Periodic, low rate (1 msg/10 min)	Static	Hierarchical (LEACH, TEEN)	Cluster heads aggregate redundant spatial data, reducing 90% of transmissions to the sink
Wildlife tracking	Event-driven, bursty	Mobile targets	Geographic (GPSR, GAF)	Location-based forwarding adapts to moving targets without global route maintenance
Structural health monitoring	Continuous, high rate (100 Hz vibration)	Static	Tree-based (RPL, CTP)	Stable tree topology minimizes routing overhead for continuous data streams
Forest fire detection	Rare events, urgent delivery	Static	Data-centric (Directed Diffusion)	Interest-driven queries flood only when events occur, saving idle energy
Smart factory	Mixed periodic + alarms	Static	QoS-aware (SPEED, MMSPEED)	Differentiated service guarantees sub-second alarm delivery alongside background telemetry

Worked Example: Routing Overhead Comparison for a 200-Node Farm

Scenario: 200 soil moisture sensors reporting every 10 minutes to a base station, deployed across 500m x 400m. Average 4-hop paths to sink.

Option A: Flat routing (AODV-like reactive)

• Route discovery: Each node discovers route on-demand. 200 nodes x route discovery every ~60 min (route timeout) = 200 discoveries/hour
• Route discovery cost: ~30 packets per discovery (flooding) = 6,000 routing packets/hour
• Data packets: 200 nodes x 6/hour = 1,200 data packets/hour
• Routing overhead ratio: 6,000 / (6,000 + 1,200) = 83% of traffic is routing overhead

Option B: Hierarchical (LEACH-like, 10 clusters)

• Cluster formation: Once per round (~20 min). 200 nodes x 2 packets = 400 packets per round, 3 rounds/hour = 1,200 routing packets/hour
• Data packets: 200 nodes send to cluster heads (200 packets) + 10 cluster heads send aggregated data to sink (10 packets) = 210 packets per collection cycle x 6/hour = 1,260 data packets/hour
• Cluster head aggregation reduces redundant spatial readings by ~70%
• Routing overhead ratio: 1,200 / (1,200 + 1,260) = 49% of traffic is routing overhead

Verdict: Hierarchical routing cuts overhead from 83% to 49% for this periodic agriculture scenario, extending network lifetime by approximately 2x. The in-network aggregation at cluster heads further reduces total transmissions by 70%, making this the clear winner for dense, periodic sensing deployments.

🏷️ Label the Diagram

Code Challenge

77.10 Summary

This chapter explored why traditional routing protocols are unsuitable for WSNs and what requirements WSN-specific protocols must meet:

Key Takeaways:

1. Traditional Routing Fails: Address-centric, peer-to-peer protocols ignore energy constraints and data semantics
2. Five Key Differences: Addressing (data vs address), pattern (many-to-one vs peer-to-peer), goal (energy vs throughput), scale (millions vs thousands), failures (common vs rare)
3. Essential Requirements: Energy efficiency, scalability, data aggregation support, robustness, and QoS guarantees
4. Common Pitfalls: Time synchronization for aggregation, link quality over hop count

77.11 Knowledge Check

Quiz: WSN Routing Challenges

Match WSN Routing Challenges to Descriptions

Order the WSN Routing Design Process

77.12 What’s Next?

Topic	Chapter	Description
Protocol Classification	WSN Routing Classification	Data-centric, hierarchical, location-based, and QoS-aware categories
Directed Diffusion	WSN Routing: Directed Diffusion	Data-centric routing with interests and gradients
Link Quality Routing	WSN Routing: Link Quality	RSSI, WMEWMA, and MIN-T metrics
Data Aggregation	WSN Routing: Data Aggregation	In-network data processing techniques