442  WSN Routing: Labs and Interactive Games

442.1 Learning Objectives

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

• Compare Routing Protocols: Experiment with AODV, DSR, and LEACH implementations
• Analyze Energy Trade-offs: Measure energy consumption differences between routing approaches
• Design Optimal Routes: Apply learned concepts to select paths in interactive simulations
• Implement Routing Decisions: Code and test routing algorithms on simulated WSN hardware

442.2 Prerequisites

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

• WSN Routing Fundamentals: Classification and challenges
• Directed Diffusion: Data-centric routing
• Data Aggregation: In-network processing
• Link Quality Routing: ETX and MIN-T metrics
• Trickle Algorithm: Network reprogramming

442.3 WSN Route Optimizer Game

Test your understanding of WSN routing by designing optimal routes in this interactive strategy game. Balance energy consumption, latency, and reliability while learning different routing protocols.

TipHow to Play

1. Select a level to learn different routing paradigms (Flat, Hierarchical, Geographic)
2. Click nodes to build routing paths from sources to the sink
3. Watch packet flow and energy depletion in real-time
4. Complete objectives while maximizing network lifetime

viewof gameConfig = {
  const container = htl.html`<div style="display: flex; flex-wrap: wrap; gap: 10px; align-items: center; margin-bottom: 15px; padding: 15px; background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); border-radius: 12px; border: 2px solid #16A085;">
    <div style="display: flex; align-items: center; gap: 8px;">
      <label style="font-weight: 600; color: #16A085;">Level:</label>
      <select id="levelSelect" style="padding: 6px 12px; border-radius: 6px; border: 1px solid #16A085; background: #0f3460; color: #e94560; font-weight: bold;">
        <option value="1">Level 1: Flat Routing</option>
        <option value="2">Level 2: Hierarchical Routing</option>
        <option value="3">Level 3: Geographic Routing</option>
      </select>
    </div>
    <div style="display: flex; align-items: center; gap: 8px;">
      <label style="font-weight: 600; color: #16A085;">Protocol:</label>
      <select id="protocolSelect" style="padding: 6px 12px; border-radius: 6px; border: 1px solid #16A085; background: #0f3460; color: #e94560; font-weight: bold;">
        <option value="manual">Manual (Your Design)</option>
        <option value="flooding">Flooding</option>
        <option value="gossiping">Gossiping</option>
        <option value="leach">LEACH</option>
        <option value="directed">Directed Diffusion</option>
      </select>
    </div>
    <button id="startGameBtn" style="padding: 8px 20px; background: linear-gradient(135deg, #16A085 0%, #1abc9c 100%); color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 700; box-shadow: 0 4px 15px rgba(22, 160, 133, 0.4);">Start Game</button>
    <button id="sendPacketBtn" style="padding: 8px 20px; background: linear-gradient(135deg, #E67E22 0%, #f39c12 100%); color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 700; box-shadow: 0 4px 15px rgba(230, 126, 34, 0.4);">Send Packet</button>
    <button id="resetGameBtn" style="padding: 8px 20px; background: linear-gradient(135deg, #95A5A6 0%, #bdc3c7 100%); color: white; border: none; border-radius: 8px; cursor: pointer; font-weight: 700;">Reset</button>
  </div>`;

  return container;
}

// Main WSN Route Optimizer Game
wsnRouteGame = {
  const width = 800;
  const height = 500;
  const INITIAL_ENERGY = 100;
  const TX_ENERGY_BASE = 2;
  const RX_ENERGY = 0.5;

  // Game state
  let state = {
    level: 1,
    protocol: "manual",
    nodes: [],
    links: [],
    selectedPath: [],
    sinkNode: null,
    sourceNodes: [],
    clusterHeads: [],
    round: 0,
    score: 0,
    packetsDelivered: 0,
    packetsLost: 0,
    totalEnergyUsed: 0,
    gameActive: false
  };

  // Level configurations
  const levelConfigs = {
    1: {
      name: "Flat Routing",
      description: "All nodes equal. Design efficient paths using flooding, gossiping, or custom routes.",
      nodeCount: 16,
      sourceCount: 3,
      objective: "Deliver 10 packets with <30% energy consumption",
      targetDelivery: 10,
      maxEnergyPercent: 30,
      enableClustering: false
    },
    2: {
      name: "Hierarchical Routing",
      description: "Select cluster heads wisely. Balance aggregation benefits against CH energy drain.",
      nodeCount: 20,
      sourceCount: 4,
      objective: "Deliver 15 packets, rotate cluster heads to extend lifetime",
      targetDelivery: 15,
      maxEnergyPercent: 40,
      enableClustering: true
    },
    3: {
      name: "Geographic Routing",
      description: "Use location information for greedy forwarding. Handle voids and dead ends.",
      nodeCount: 24,
      sourceCount: 5,
      objective: "Deliver 20 packets using location-based forwarding",
      targetDelivery: 20,
      maxEnergyPercent: 35,
      enableClustering: false
    }
  };

  function initializeNetwork(level) {
    const config = levelConfigs[level];
    state.nodes = [];
    state.links = [];
    state.selectedPath = [];
    state.round = 0;
    state.packetsDelivered = 0;
    state.packetsLost = 0;
    state.totalEnergyUsed = 0;

    // Create sink node
    state.sinkNode = {
      id: 0, x: width / 2, y: 50,
      energy: Infinity, isSink: true, isSource: false, isClusterHead: false
    };
    state.nodes.push(state.sinkNode);

    // Create sensor nodes
    const cols = Math.ceil(Math.sqrt(config.nodeCount));
    const rows = Math.ceil(config.nodeCount / cols);
    const cellWidth = (width - 100) / cols;
    const cellHeight = (height - 200) / rows;

    for (let i = 0; i < config.nodeCount; i++) {
      const col = i % cols;
      const row = Math.floor(i / cols);
      state.nodes.push({
        id: i + 1,
        x: 50 + col * cellWidth + cellWidth/2 + (Math.random() - 0.5) * cellWidth * 0.4,
        y: 150 + row * cellHeight + cellHeight/2 + (Math.random() - 0.5) * cellHeight * 0.4,
        energy: INITIAL_ENERGY, isSink: false, isSource: false, isClusterHead: false
      });
    }

    // Designate sources
    state.sourceNodes = [];
    const sensorNodes = state.nodes.filter(n => !n.isSink);
    const bottomNodes = sensorNodes.sort((a, b) => b.y - a.y).slice(0, config.sourceCount);
    bottomNodes.forEach(n => { n.isSource = true; state.sourceNodes.push(n); });

    // Create links
    createLinks();
    state.level = level;
    state.gameActive = true;
  }

  function createLinks() {
    state.links = [];
    const maxLinkDist = 150;
    for (let i = 0; i < state.nodes.length; i++) {
      for (let j = i + 1; j < state.nodes.length; j++) {
        const n1 = state.nodes[i], n2 = state.nodes[j];
        const dist = Math.sqrt((n1.x - n2.x) ** 2 + (n1.y - n2.y) ** 2);
        if (dist < maxLinkDist) {
          const quality = Math.max(0.5, 1 - (dist / maxLinkDist) * 0.5 + (Math.random() - 0.5) * 0.2);
          state.links.push({ source: n1.id, target: n2.id, quality: Math.min(1, Math.max(0.3, quality)), active: false });
        }
      }
    }
  }

  function getEnergyColor(energy) {
    if (energy === Infinity) return "#16A085";
    if (energy <= 0) return "#2c2c2c";
    if (energy < 20) return "#E74C3C";
    if (energy < 40) return "#E67E22";
    if (energy < 60) return "#F1C40F";
    return "#16A085";
  }

  // Create SVG
  const svg = d3.create("svg")
    .attr("width", width)
    .attr("height", height)
    .style("background", "linear-gradient(180deg, #0f0c29 0%, #302b63 50%, #24243e 100%)")
    .style("border-radius", "12px")
    .style("border", "2px solid #16A085");

  function render() {
    svg.selectAll("*").remove();
    const config = levelConfigs[state.level] || levelConfigs[1];

    // Title
    svg.append("text").attr("x", width / 2).attr("y", 25).attr("text-anchor", "middle")
      .attr("font-size", "18px").attr("font-weight", "bold").attr("fill", "#16A085")
      .text(`WSN Route Optimizer - ${config.name}`);

    // Draw links
    state.links.forEach(link => {
      const source = state.nodes.find(n => n.id === link.source);
      const target = state.nodes.find(n => n.id === link.target);
      if (!source || !target) return;

      const inPath = state.selectedPath.length > 1 &&
        state.selectedPath.some((id, i) => {
          if (i === state.selectedPath.length - 1) return false;
          const nextId = state.selectedPath[i + 1];
          return (id === link.source && nextId === link.target) ||
                 (id === link.target && nextId === link.source);
        });

      svg.append("line")
        .attr("x1", source.x).attr("y1", source.y)
        .attr("x2", target.x).attr("y2", target.y)
        .attr("stroke", inPath ? "#00ff88" : (link.quality > 0.8 ? "rgba(22, 160, 133, 0.6)" : link.quality > 0.6 ? "rgba(241, 196, 15, 0.5)" : "rgba(231, 76, 60, 0.4)"))
        .attr("stroke-width", inPath ? 3 : 1.5)
        .attr("opacity", inPath ? 1 : 0.6);
    });

    // Draw nodes
    state.nodes.forEach(node => {
      const g = svg.append("g").attr("transform", `translate(${node.x}, ${node.y})`).style("cursor", "pointer");

      const inPath = state.selectedPath.includes(node.id);
      if (inPath) {
        g.append("circle").attr("r", 22).attr("fill", "none").attr("stroke", "#00ff88").attr("stroke-width", 3).attr("opacity", 0.7);
      }

      let nodeSize = node.isSink ? 25 : (node.isSource ? 18 : 15);
      g.append("circle").attr("r", nodeSize).attr("fill", getEnergyColor(node.energy)).attr("stroke", node.isSink ? "#16A085" : (node.isSource ? "#E67E22" : "#333")).attr("stroke-width", 2);

      if (node.isSink) {
        g.append("text").attr("y", 5).attr("text-anchor", "middle").attr("font-size", "12px").attr("font-weight", "bold").attr("fill", "#fff").text("SINK");
      } else {
        g.append("text").attr("y", 4).attr("text-anchor", "middle").attr("font-size", "10px").attr("font-weight", "bold").attr("fill", "#fff").text(node.id);
        if (node.isSource) {
          g.append("text").attr("y", -nodeSize - 5).attr("text-anchor", "middle").attr("font-size", "9px").attr("fill", "#E67E22").text("SRC");
        }
      }
    });

    // Stats
    const statsY = height - 80;
    svg.append("rect").attr("x", 10).attr("y", statsY).attr("width", 180).attr("height", 70).attr("fill", "rgba(0,0,0,0.7)").attr("rx", 8);

    const stats = [
      { label: "Round", value: state.round },
      { label: "Delivered", value: state.packetsDelivered, color: "#16A085" },
      { label: "Lost", value: state.packetsLost, color: "#E74C3C" }
    ];

    stats.forEach((stat, i) => {
      svg.append("text").attr("x", 20).attr("y", statsY + 20 + i * 18).attr("font-size", "12px").attr("fill", "#aaa").text(`${stat.label}:`);
      svg.append("text").attr("x", 130).attr("y", statsY + 20 + i * 18).attr("font-size", "12px").attr("font-weight", "bold").attr("fill", stat.color || "#fff").text(stat.value);
    });
  }

  initializeNetwork(1);
  render();

  // Button handlers
  const startBtn = document.querySelector("#startGameBtn");
  const sendBtn = document.querySelector("#sendPacketBtn");
  const resetBtn = document.querySelector("#resetGameBtn");
  const levelSelect = document.querySelector("#levelSelect");

  if (startBtn) startBtn.onclick = () => { initializeNetwork(parseInt(levelSelect?.value || "1")); render(); };
  if (resetBtn) resetBtn.onclick = () => { initializeNetwork(parseInt(levelSelect?.value || "1")); render(); };
  if (levelSelect) levelSelect.onchange = () => { initializeNetwork(parseInt(levelSelect.value)); render(); };

  return svg.node();
}

NoteGame Scenarios

Single-Path vs Multi-Path Routing: In manual mode, try creating redundant paths. Multi-path routing improves reliability but increases energy consumption.

Cluster Head Selection (Level 2): LEACH rotates cluster heads to balance energy drain. Watch how fixed CH selection creates hot spots.

Energy-Aware Route Selection: Avoid nodes with low energy (red). The ETX metric favors reliable links over shortest paths.

Handling Node Failures: When nodes die (turn dark), the network must adapt. Geographic routing can route around voids.

Hot Spot Problem: Nodes near the sink relay more traffic. Use hierarchical routing or multi-path to distribute load.

TipStrategy Tips

1. Level 1 (Flat): Compare flooding (high overhead, reliable) vs gossiping (low overhead, less reliable). Use Directed Diffusion for a balance.

2. Level 2 (Hierarchical): Let LEACH auto-select cluster heads. Watch how rotation extends network lifetime vs fixed CH.

3. Level 3 (Geographic): Observe greedy forwarding toward the sink. Dead nodes create “voids” that require perimeter routing.

4. Manual Mode: Click nodes to build custom paths. Start from a source, connect through intermediate nodes to the sink. Monitor link quality percentages.

---

442.4 Hands-On Lab: Multi-Hop Routing Simulation

⏱️ ~45 min | ⭐⭐⭐ Advanced | 🧪 Hands-On Lab

442.4.1 Lab Overview

This hands-on lab simulates a Wireless Sensor Network with multiple ESP32 nodes demonstrating different routing protocols. You’ll experiment with routing decisions, energy-aware path selection, and compare the performance of AODV, DSR, and LEACH protocols in real-time.

What You’ll Learn:

• How multi-hop routing works in wireless sensor networks
• Differences between reactive (AODV, DSR) and proactive (LEACH) routing
• Energy-aware routing decisions and their impact on network lifetime
• Route discovery, maintenance, and recovery mechanisms
• Cluster-based routing and aggregation strategies

442.4.2 Lab Setup

The simulation creates a 9-node WSN topology with:

• 3 Sensor Nodes (S1, S2, S3) - Generate temperature/humidity data
• 4 Intermediate Nodes (R1, R2, R3, R4) - Forward packets and aggregate data
• 1 Cluster Head (CH) - Coordinates LEACH protocol
• 1 Sink Node (SINK) - Destination for all data

Each node has a simulated battery level that depletes with transmission/reception, demonstrating energy-aware routing.

442.4.3 Network Topology

   S1 ──┬── R1 ──┬── CH ── SINK
        │        │    │
   S2 ──┼── R2 ──┤    │
        │        │    │
   S3 ──┴── R3 ──┴── R4

Links: S1↔R1, S1↔R2, S2↔R2, S2↔R3
       S3↔R3, S3↔R4, R1↔R2, R2↔R3
       R3↔R4, R1↔CH, R2↔CH, R4↔CH
       CH↔SINK

442.4.4 Key Code Sections

The complete simulation code is available in the Wokwi editor. Key sections include:

AODV Route Discovery:

void aodvRouteDiscovery(int source, int dest) {
  // Flood RREQ to neighbors
  for (int i = 0; i < NUM_NODES; i++) {
    if (topology[source][i] && nodes[i].active) {
      updateEnergy(source, true);   // TX cost
      updateEnergy(i, false);       // RX cost
      // Forward RREQ...
    }
  }
}

LEACH Cluster Formation:

void leachClusterFormation() {
  // Probabilistic cluster head selection
  for (int i = 0; i < numNodes; i++) {
    if (random(0, 100) < p * 100) {
      nodes[i].isClusterHead = true;
    }
  }
  // Assign members to nearest CH
}

Energy-Aware Forwarding:

int getNextHop(int current, int dest) {
  int bestHop = -1, bestMetric = 999999;
  for (int i = 0; i < MAX_ROUTES; i++) {
    if (routingTable[current][i].valid) {
      int metric = routingTable[current][i].hopCount;
      // Penalize low-energy nodes
      if (nodes[nextHop].energy < 30) metric += 10;
      if (metric < bestMetric) {
        bestMetric = metric;
        bestHop = routingTable[current][i].nextHop;
      }
    }
  }
  return bestHop;
}

442.4.5 Challenge Exercises

WarningHands-On Challenges

Try these modifications to deepen your understanding:

1. Energy-Aware Path Selection
   • Modify getNextHop() to prioritize high-energy nodes
   • Implement adaptive energy thresholds based on network-wide energy levels
   • Compare network lifetime with and without energy awareness
2. Route Quality Metrics
   • Add link quality estimation based on signal strength (RSSI)
   • Implement Expected Transmission Count (ETX) metric
   • Update calculateLinkQuality() to factor in packet loss
3. LEACH Cluster Rotation
   • Implement probabilistic cluster head election (5% probability)
   • Rotate cluster heads based on residual energy
   • Compare energy consumption across nodes
4. Multipath Routing
   • Modify DSR to maintain multiple routes
   • Implement route splitting for load balancing
   • Measure improvement in delivery rate
5. Route Recovery
   • Add RERR (Route Error) packet handling for broken links
   • Implement local route repair before triggering new discovery
   • Measure reduction in route discovery overhead
6. Protocol Comparison
   • Run each protocol for 2 minutes and record statistics
   • Compare delivery rate, latency, and energy consumption
   • Analyze which protocol performs best under different network densities

442.4.6 Expected Learning Outcomes

After completing this lab, you should be able to:

• Explain the differences between reactive (AODV, DSR) and proactive (LEACH) routing
• Identify when energy-aware routing improves network lifetime
• Analyze the trade-offs between hop count and energy consumption
• Implement route discovery and maintenance mechanisms
• Evaluate protocol performance under different network conditions
• Design hierarchical routing strategies for large-scale WSNs

442.4.7 Key Observations

Protocol	Route Discovery	Energy Efficiency	Scalability	Best Use Case
AODV	On-demand (flooded RREQ)	Moderate	Good	Mobile, dynamic networks
DSR	On-demand (source routing)	Low overhead	Limited	Small networks, stable topology
LEACH	Cluster-based (periodic)	High (aggregation)	Excellent	Dense, static sensor deployments

TipReal-World Applications

• AODV: Smart city IoT with mobile nodes (vehicles, wearables)
• DSR: Indoor sensor networks with stable topology
• LEACH: Agricultural monitoring with thousands of static sensors
• Energy-Aware Routing: Battery-powered environmental monitoring

---

442.5 Comprehensive Review Quiz

Test your understanding of WSN routing protocols with this comprehensive quiz.

NoteQuiz: Comprehensive Review

Question 1: In LEACH (Low-Energy Adaptive Clustering Hierarchy), how does the protocol distribute energy consumption evenly across all nodes?

Explanation: LEACH uses randomized rotation of cluster head roles. Each round, every node decides independently whether to become cluster head based on probability P and rounds since last time as CH. Over many rounds, every node spends approximately P% of time as CH, balancing energy consumption. Since CH role consumes 3-5x more energy, rotation prevents any single node from dying early.

Question 2: TEEN (Threshold-sensitive Energy Efficient sensor Network) protocol is designed for reactive monitoring. How does it reduce transmissions compared to proactive protocols?

Explanation: TEEN’s threshold-based transmission: (1) Hard threshold (HT): Minimum value to trigger transmission. (2) Soft threshold (ST): Minimum change to trigger transmission. Node transmits only when value crosses HT AND differs by ≥ST from last transmission. During stable periods with temperature below HT: 0 transmissions. Result: 99%+ reduction in transmissions during normal operation.

Question 3: In Directed Diffusion, what is the purpose of the “reinforcement” phase after initial data delivery?

Explanation: Directed Diffusion reinforcement: (1) Interest propagation creates multiple gradients from source to sink. (2) Source sends low-rate exploratory data along ALL gradients. (3) Sink evaluates path quality and sends reinforcement along best path, increasing data rate. (4) Non-reinforced paths expire, focusing traffic on proven path.

Question 4: PEGASIS organizes sensors into a chain. What advantage does chain topology provide over cluster-based approaches like LEACH?

Explanation: PEGASIS chain formation: Data flows along chain from one end to the other, aggregating at each hop. Each node transmits to nearest neighbor (typically 10-20m) instead of cluster head (potentially 50-100m). Since energy is proportional to distance squared or fourth power, short transmissions save significant energy. Trade-off: Higher latency since data traverses entire chain.

---

442.6 Summary

This chapter provided hands-on experience with WSN routing protocols:

Key Takeaways:

1. Interactive Learning: The WSN Route Optimizer game lets you experiment with different routing paradigms and see energy trade-offs in real-time

2. Protocol Comparison: AODV, DSR, and LEACH each have strengths for different network conditions (mobile vs. static, small vs. large)

3. Energy Awareness: Routing decisions must consider node energy levels to maximize network lifetime

4. Practical Implementation: The Wokwi lab provides working code for routing algorithms that can be modified and tested

5. Measurement Matters: Always compare delivery rate, latency, AND energy consumption when evaluating protocols

---

NoteRelated Chapters

• WSN Routing Fundamentals - Overview of WSN routing challenges and classification
• WSN Routing: Directed Diffusion - Data-centric routing with interests and gradients
• WSN Routing: Data Aggregation - In-network data processing techniques
• WSN Routing: Link Quality - RSSI, WMEWMA, and MIN-T metrics
• WSN Routing: Trickle Algorithm - Network reprogramming protocol