646  Converged Networks and Channel Access

646.1 Learning Objectives

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

• Compare Network Architectures: Contrast legacy separate networks with modern converged infrastructure
• Evaluate Convergence Benefits: Explain economic, efficiency, and scalability advantages of converged networks
• Understand Channel Access: Describe how CSMA/CA enables shared wireless medium access
• Apply QoS Concepts: Understand how Quality of Service prioritizes critical IoT traffic

646.2 Prerequisites

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

• Packet Switching and Network Performance: Understanding multiplexing, throughput, and network efficiency
• Networking Basics: Core networking concepts and terminology

ImportantWhy Converged Networks Matter for IoT

Smart buildings run on converged networks. Instead of separate wiring for security cameras, access control, HVAC sensors, and voice systems, one IP network carries everything. This dramatically reduces installation costs and enables intelligent automation - your access control can talk to your HVAC to save energy when rooms are unoccupied.

---

646.3 Traditional Separate Networks

Before convergence, organizations needed separate infrastructure for each service:

%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#2C3E50', 'primaryTextColor': '#fff', 'primaryBorderColor': '#16A085', 'lineColor': '#E67E22', 'secondaryColor': '#16A085', 'tertiaryColor': '#E8F6F3', 'clusterBkg': '#E8F6F3', 'clusterBorder': '#16A085', 'fontSize': '12px'}}}%%
graph TB
    subgraph Legacy["Legacy Separate Networks"]
        Phone["Phone System<br/>(PSTN Lines)"]
        Video["Video System<br/>(Coax Cables)"]
        Data["Data Network<br/>(Ethernet)"]
        Building["Building Auto<br/>(Proprietary)"]
    end

    Phone --> PhoneInfra["Phone Infrastructure<br/>- PBX system<br/>- Phone wiring"]
    Video --> VideoInfra["Video Infrastructure<br/>- Coax cables<br/>- DVR systems"]
    Data --> DataInfra["Data Infrastructure<br/>- Ethernet switches<br/>- Cat5/6 cables"]
    Building --> BuildingInfra["Building Infrastructure<br/>- Proprietary control<br/>- Custom wiring"]

    style Phone fill:#E67E22,stroke:#2C3E50,color:#fff
    style Video fill:#E67E22,stroke:#2C3E50,color:#fff
    style Data fill:#E67E22,stroke:#2C3E50,color:#fff
    style Building fill:#E67E22,stroke:#2C3E50,color:#fff

Figure 646.1: Legacy separate network infrastructures for phone, video, data, and building systems

{fig-alt=“Legacy network architecture diagram showing four separate infrastructure systems for phone, video, data, and building automation, each requiring dedicated wiring and equipment”}

Problems: - High cost (multiple infrastructures) - Complex management (different standards) - Energy inefficiency - Limited scalability

---

646.4 Modern Converged Networks

21st century technological advances enable all services to run over a single data network infrastructure.

%%{init: {'theme': 'base', 'themeVariables': { 'primaryColor': '#2C3E50', 'primaryTextColor': '#fff', 'primaryBorderColor': '#16A085', 'lineColor': '#E67E22', 'secondaryColor': '#16A085', 'tertiaryColor': '#E8F6F3', 'clusterBkg': '#E8F6F3', 'clusterBorder': '#16A085', 'fontSize': '13px'}}}%%
graph TB
    VoIP["VoIP Phones"]
    IPCam["IP Cameras"]
    Computers["Computers"]
    IoT["IoT Sensors"]

    VoIP --> Network["Unified IP Network<br/>- Single Ethernet/Wi-Fi<br/>- PoE support<br/>- QoS management"]
    IPCam --> Network
    Computers --> Network
    IoT --> Network

    Network --> Switch["Network Switch<br/>- VLAN segmentation<br/>- Traffic prioritization<br/>- Centralized management"]

    style VoIP fill:#16A085,stroke:#2C3E50,color:#fff
    style IPCam fill:#16A085,stroke:#2C3E50,color:#fff
    style Computers fill:#16A085,stroke:#2C3E50,color:#fff
    style IoT fill:#16A085,stroke:#2C3E50,color:#fff
    style Network fill:#2C3E50,stroke:#16A085,color:#fff
    style Switch fill:#E67E22,stroke:#2C3E50,color:#fff

Figure 646.2: Modern converged IP network unifying all device types on single infrastructure

{fig-alt=“Modern converged network diagram showing VoIP phones, IP cameras, computers, and IoT sensors all connected to single unified IP network infrastructure with centralized management”}

Benefits for IoT: - Economic savings: One infrastructure supports all devices - Energy efficiency: Shared power and networking equipment - Scalability: Easy to add new devices and services - Flexibility: Connect anything anywhere

WarningTradeoff: Converged Network vs Separate Networks

Option A: Single converged IP network for all traffic (voice, video, data, IoT) - lower cost, simpler management, single skill set required

Option B: Separate dedicated networks for different traffic types - guaranteed performance isolation, simpler QoS, no cross-traffic interference

Decision Factors: Choose converged when cost reduction is priority, when QoS mechanisms are robust enough, or for typical enterprise/smart building deployments. Choose separate networks for safety-critical industrial systems where latency guarantees are mandatory, or when legacy systems cannot be migrated. Modern best practice: converged physical infrastructure with logical separation via VLANs and strict QoS policies - getting benefits of both approaches.

Example: A modern smart building uses one Ethernet/Wi-Fi network for: - Temperature sensors - Security cameras - Access control systems - HVAC control - Lighting systems - Occupancy sensors - Voice communications

---

646.5 Converged Network Economics

TipUnderstanding Check: Converged Network Economics

Scenario: Your company manages a 10-story office building that currently has four separate networks: traditional phone system (PSTN lines with PBX), security camera system (coax cables with DVR), computer network (Ethernet), and building automation (proprietary BACnet wiring). The CFO asks you to evaluate upgrading to a converged IP network supporting 200 VoIP phones, 500 computers, 100 IP cameras, and 1000 IoT sensors on one infrastructure.

Current costs: Four separate infrastructures cost approximately $200,000-800,000 to install and maintain.

Think about: 1. What are the economic trade-offs between maintaining four specialized networks versus one unified IP network? 2. How does converging voice, video, data, and building automation onto a single network affect operational complexity?

Key Insight: Converged networks use one IP-based infrastructure for all services instead of separate dedicated networks. A single unified network costs $50,000-200,000 to deploy - representing 60-75% cost savings compared to four independent systems. Energy efficiency improves dramatically: one set of switches, routers, and cabling replaces four independent systems. Management simplifies: a single IT team maintains one infrastructure instead of requiring specialists for phone systems, video systems, and building automation. Modern smart buildings leverage Power over Ethernet (PoE) to provide both power and data on the same cable, further reducing installation costs.

Verify Your Understanding: - If you needed to add 500 new IoT environmental sensors to this building, how would deployment differ between the converged network versus the legacy approach? Consider cabling requirements, power delivery, configuration time, and ongoing maintenance.

---

646.6 Channel Access: CSMA/CA

When multiple wireless devices share the same radio channel, they need a mechanism to avoid collisions. Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA) is the foundation of Wi-Fi and many IoT protocols.

646.6.1 How CSMA/CA Works

1. Carrier Sensing: Before transmitting, each node listens to the channel
2. Backoff Timer: If channel is busy, node picks a random backoff time from contention window [0, CW]
3. Countdown: When channel is idle, backoff counter decrements each slot
4. Transmission: When backoff reaches 0, node transmits
5. Collision: If multiple nodes reach 0 simultaneously, collision occurs
6. Exponential Backoff: After collision, CW doubles (up to CW_max), providing fairness

646.6.2 Protocol Efficiency Comparison

Protocol	Max Efficiency	Description
Pure ALOHA	~18.4%	Transmit anytime, high collisions
Slotted ALOHA	~36.8%	Time slots reduce collisions
CSMA (1-persistent)	~53%	Listen before transmit
CSMA/CA	50-70%+	Carrier sensing + backoff

NoteInteractive: CSMA/CA Channel Access Demo

This simulation demonstrates how Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA) works in wireless networks like Wi-Fi and IoT protocols. Watch how multiple nodes coordinate access to a shared channel using carrier sensing, random backoff, and exponential backoff after collisions.

viewof startSimulation = Inputs.button("Start Simulation", {reduce: () => Date.now()})
viewof resetSimulation = Inputs.button("Reset", {reduce: () => Date.now()})
viewof simulationSpeed = Inputs.range([0.5, 3], {value: 1, step: 0.1, label: "Speed"})

// Simulation parameters
numNodes = 4
slotTime = 20 // microseconds (conceptual)
sifsTime = 10
difsTime = 50
maxBackoff = 1023
initialCW = 15 // Initial contention window (CW_min - 1)

// Generate simulation data based on start trigger
simulationData = {
  const trigger = startSimulation;
  const reset = resetSimulation;

  // Initialize nodes with transmission desires
  const nodes = [];
  for (let i = 0; i < numNodes; i++) {
    nodes.push({
      id: i,
      name: `Node ${String.fromCharCode(65 + i)}`,
      color: ["#2C3E50", "#16A085", "#E67E22", "#8E44AD"][i],
      wantsToTransmit: Math.random() > 0.2, // 80% chance wants to transmit
      backoffCounter: Math.floor(Math.random() * (initialCW + 1)),
      contentionWindow: initialCW,
      collisions: 0,
      successfulTx: 0,
      state: "idle" // idle, sensing, backoff, transmitting, collision
    });
  }

  // Generate timeline events
  const timeline = [];
  const totalSlots = 40;
  let channelBusy = false;
  let currentTime = 0;

  // Create a copy for simulation
  const simNodes = nodes.map(n => ({...n}));

  for (let slot = 0; slot < totalSlots; slot++) {
    currentTime = slot * slotTime;

    // Phase 1: Carrier Sensing
    const sensingNodes = simNodes.filter(n => n.wantsToTransmit && n.state !== "transmitting");

    // Phase 2: Check if channel is busy
    const transmittingNodes = simNodes.filter(n => n.state === "transmitting");
    channelBusy = transmittingNodes.length > 0;

    // Phase 3: Backoff countdown or transmission attempt
    const attemptingNodes = [];

    for (const node of simNodes) {
      if (!node.wantsToTransmit) continue;

      if (node.state === "transmitting") {
        // Finish transmission after 3 slots
        if (slot - node.txStartSlot >= 3) {
          node.state = "idle";
          node.wantsToTransmit = Math.random() > 0.5; // May want to transmit again
          if (node.wantsToTransmit) {
            node.backoffCounter = Math.floor(Math.random() * (node.contentionWindow + 1));
            node.state = "backoff";
          }
        }
        continue;
      }

      if (channelBusy) {
        // Channel busy - freeze backoff
        node.state = "sensing";
        timeline.push({
          slot,
          time: currentTime,
          nodeId: node.id,
          nodeName: node.name,
          color: node.color,
          event: "sense-busy",
          backoff: node.backoffCounter,
          cw: node.contentionWindow
        });
      } else {
        // Channel idle
        if (node.backoffCounter > 0) {
          // Decrement backoff
          node.backoffCounter--;
          node.state = "backoff";
          timeline.push({
            slot,
            time: currentTime,
            nodeId: node.id,
            nodeName: node.name,
            color: node.color,
            event: "backoff",
            backoff: node.backoffCounter,
            cw: node.contentionWindow
          });
        } else {
          // Backoff expired - attempt transmission
          attemptingNodes.push(node);
        }
      }
    }

    // Phase 4: Handle transmission attempts
    if (attemptingNodes.length === 1) {
      // Successful transmission
      const node = attemptingNodes[0];
      node.state = "transmitting";
      node.txStartSlot = slot;
      node.successfulTx++;
      node.contentionWindow = initialCW; // Reset CW on success
      timeline.push({
        slot,
        time: currentTime,
        nodeId: node.id,
        nodeName: node.name,
        color: node.color,
        event: "transmit-success",
        backoff: 0,
        cw: node.contentionWindow
      });
    } else if (attemptingNodes.length > 1) {
      // Collision!
      for (const node of attemptingNodes) {
        node.collisions++;
        // Exponential backoff: double CW (up to max)
        node.contentionWindow = Math.min(node.contentionWindow * 2 + 1, maxBackoff);
        node.backoffCounter = Math.floor(Math.random() * (node.contentionWindow + 1));
        node.state = "backoff";
        timeline.push({
          slot,
          time: currentTime,
          nodeId: node.id,
          nodeName: node.name,
          color: node.color,
          event: "collision",
          backoff: node.backoffCounter,
          cw: node.contentionWindow
        });
      }
    }
  }

  // Calculate statistics
  const totalCollisions = simNodes.reduce((sum, n) => sum + n.collisions, 0);
  const totalSuccess = simNodes.reduce((sum, n) => sum + n.successfulTx, 0);
  const totalAttempts = totalCollisions + totalSuccess;

  // ALOHA efficiency comparison (theoretical)
  const alohaEfficiency = numNodes > 0 ? (1/Math.E) * 100 : 0; // ~36.8% for slotted ALOHA
  const csmaEfficiency = totalAttempts > 0 ? (totalSuccess / totalAttempts) * 100 : 0;

  return {
    nodes: simNodes,
    timeline,
    stats: {
      totalSlots,
      totalCollisions,
      totalSuccess,
      totalAttempts,
      csmaEfficiency: csmaEfficiency.toFixed(1),
      alohaEfficiency: alohaEfficiency.toFixed(1),
      channelUtilization: ((totalSuccess * 3) / totalSlots * 100).toFixed(1)
    }
  };
}

// Animated timeline visualization
timelineViz = {
  const width = 800;
  const height = 320;
  const margin = {top: 40, right: 30, bottom: 60, left: 80};
  const innerWidth = width - margin.left - margin.right;
  const innerHeight = height - margin.top - margin.bottom;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("width", "100%")
    .attr("height", height)
    .style("font-family", "system-ui, sans-serif");

  // Background
  svg.append("rect")
    .attr("width", width)
    .attr("height", height)
    .attr("fill", "#f8f9fa");

  const g = svg.append("g")
    .attr("transform", `translate(${margin.left},${margin.top})`);

  // Title
  svg.append("text")
    .attr("x", width / 2)
    .attr("y", 20)
    .attr("text-anchor", "middle")
    .attr("font-size", 14)
    .attr("font-weight", "bold")
    .attr("fill", "#2C3E50")
    .text("CSMA/CA Channel Access Timeline");

  // Time axis
  const xScale = d3.scaleLinear()
    .domain([0, simulationData.stats.totalSlots])
    .range([0, innerWidth]);

  // Node axis
  const yScale = d3.scaleBand()
    .domain(simulationData.nodes.map(n => n.name))
    .range([0, innerHeight])
    .padding(0.2);

  // Grid lines
  g.append("g")
    .attr("class", "grid")
    .selectAll("line")
    .data(d3.range(0, simulationData.stats.totalSlots + 1, 5))
    .join("line")
    .attr("x1", d => xScale(d))
    .attr("x2", d => xScale(d))
    .attr("y1", 0)
    .attr("y2", innerHeight)
    .attr("stroke", "#dee2e6")
    .attr("stroke-dasharray", "2,2");

  // X axis
  g.append("g")
    .attr("transform", `translate(0,${innerHeight})`)
    .call(d3.axisBottom(xScale).ticks(8))
    .append("text")
    .attr("x", innerWidth / 2)
    .attr("y", 35)
    .attr("fill", "#2C3E50")
    .attr("text-anchor", "middle")
    .text("Time Slots");

  // Y axis
  g.append("g")
    .call(d3.axisLeft(yScale));

  // Node lanes (background)
  g.selectAll(".node-lane")
    .data(simulationData.nodes)
    .join("rect")
    .attr("class", "node-lane")
    .attr("x", 0)
    .attr("y", d => yScale(d.name))
    .attr("width", innerWidth)
    .attr("height", yScale.bandwidth())
    .attr("fill", (d, i) => i % 2 === 0 ? "#ffffff" : "#f8f9fa")
    .attr("stroke", "#dee2e6");

  // Event symbols
  const eventWidth = innerWidth / simulationData.stats.totalSlots;

  // Draw events
  simulationData.timeline.forEach(event => {
    const x = xScale(event.slot);
    const y = yScale(event.nodeName) + yScale.bandwidth() / 2;

    if (event.event === "transmit-success") {
      // Green rectangle for successful transmission
      g.append("rect")
        .attr("x", x)
        .attr("y", yScale(event.nodeName) + 2)
        .attr("width", eventWidth * 3) // 3 slots for transmission
        .attr("height", yScale.bandwidth() - 4)
        .attr("fill", "#16A085")
        .attr("opacity", 0.8)
        .attr("rx", 3);

      g.append("text")
        .attr("x", x + eventWidth * 1.5)
        .attr("y", y + 4)
        .attr("text-anchor", "middle")
        .attr("font-size", 10)
        .attr("fill", "white")
        .attr("font-weight", "bold")
        .text("TX");

    } else if (event.event === "collision") {
      // Red X for collision
      g.append("text")
        .attr("x", x + eventWidth / 2)
        .attr("y", y + 5)
        .attr("text-anchor", "middle")
        .attr("font-size", 16)
        .attr("fill", "#E74C3C")
        .attr("font-weight", "bold")
        .text("X");

    } else if (event.event === "backoff") {
      // Yellow/orange circle with backoff counter
      g.append("circle")
        .attr("cx", x + eventWidth / 2)
        .attr("cy", y)
        .attr("r", 8)
        .attr("fill", "#F39C12")
        .attr("opacity", 0.7);

      g.append("text")
        .attr("x", x + eventWidth / 2)
        .attr("y", y + 3)
        .attr("text-anchor", "middle")
        .attr("font-size", 8)
        .attr("fill", "white")
        .attr("font-weight", "bold")
        .text(event.backoff);

    } else if (event.event === "sense-busy") {
      // Gray diamond for sensing busy channel
      g.append("text")
        .attr("x", x + eventWidth / 2)
        .attr("y", y + 4)
        .attr("text-anchor", "middle")
        .attr("font-size", 12)
        .attr("fill", "#7F8C8D")
        .text("◆");
    }
  });

  // Legend
  const legend = svg.append("g")
    .attr("transform", `translate(${margin.left}, ${height - 20})`);

  const legendItems = [
    {symbol: "rect", color: "#16A085", label: "Successful TX"},
    {symbol: "text", color: "#E74C3C", label: "Collision", text: "X"},
    {symbol: "circle", color: "#F39C12", label: "Backoff (count)"},
    {symbol: "text", color: "#7F8C8D", label: "Sense Busy", text: "◆"}
  ];

  legendItems.forEach((item, i) => {
    const xPos = i * 150;

    if (item.symbol === "rect") {
      legend.append("rect")
        .attr("x", xPos)
        .attr("y", -8)
        .attr("width", 20)
        .attr("height", 12)
        .attr("fill", item.color)
        .attr("rx", 2);
    } else if (item.symbol === "circle") {
      legend.append("circle")
        .attr("cx", xPos + 10)
        .attr("cy", -2)
        .attr("r", 6)
        .attr("fill", item.color);
    } else {
      legend.append("text")
        .attr("x", xPos + 10)
        .attr("y", 2)
        .attr("text-anchor", "middle")
        .attr("font-size", 12)
        .attr("fill", item.color)
        .attr("font-weight", "bold")
        .text(item.text);
    }

    legend.append("text")
      .attr("x", xPos + 28)
      .attr("y", 2)
      .attr("font-size", 11)
      .attr("fill", "#2C3E50")
      .text(item.label);
  });

  return svg.node();
}

// Statistics display
statsDisplay = {
  const stats = simulationData.stats;
  const nodes = simulationData.nodes;

  return html`
    <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-top: 15px;">
      <div style="background: linear-gradient(135deg, #16A085, #1ABC9C); color: white; padding: 15px; border-radius: 8px; text-align: center;">
        <div style="font-size: 24px; font-weight: bold;">${stats.totalSuccess}</div>
        <div style="font-size: 12px; opacity: 0.9;">Successful Transmissions</div>
      </div>
      <div style="background: linear-gradient(135deg, #E74C3C, #C0392B); color: white; padding: 15px; border-radius: 8px; text-align: center;">
        <div style="font-size: 24px; font-weight: bold;">${stats.totalCollisions}</div>
        <div style="font-size: 12px; opacity: 0.9;">Collisions</div>
      </div>
      <div style="background: linear-gradient(135deg, #3498DB, #2980B9); color: white; padding: 15px; border-radius: 8px; text-align: center;">
        <div style="font-size: 24px; font-weight: bold;">${stats.channelUtilization}%</div>
        <div style="font-size: 12px; opacity: 0.9;">Channel Utilization</div>
      </div>
      <div style="background: linear-gradient(135deg, #9B59B6, #8E44AD); color: white; padding: 15px; border-radius: 8px; text-align: center;">
        <div style="font-size: 24px; font-weight: bold;">${stats.csmaEfficiency}%</div>
        <div style="font-size: 12px; opacity: 0.9;">CSMA/CA Efficiency</div>
      </div>
    </div>
  `;
}

// Contention Window growth visualization
cwGrowthViz = {
  const width = 400;
  const height = 200;
  const margin = {top: 30, right: 20, bottom: 40, left: 50};

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("width", "100%")
    .attr("height", height)
    .style("font-family", "system-ui, sans-serif");

  svg.append("rect")
    .attr("width", width)
    .attr("height", height)
    .attr("fill", "#f8f9fa");

  svg.append("text")
    .attr("x", width / 2)
    .attr("y", 18)
    .attr("text-anchor", "middle")
    .attr("font-size", 12)
    .attr("font-weight", "bold")
    .attr("fill", "#2C3E50")
    .text("Contention Window Growth (Exponential Backoff)");

  const g = svg.append("g")
    .attr("transform", `translate(${margin.left},${margin.top})`);

  const innerWidth = width - margin.left - margin.right;
  const innerHeight = height - margin.top - margin.bottom;

  // Data for CW growth
  const cwData = [];
  let cw = initialCW;
  for (let i = 0; i <= 6; i++) {
    cwData.push({collision: i, cw: cw});
    cw = Math.min(cw * 2 + 1, maxBackoff);
  }

  const xScale = d3.scaleLinear()
    .domain([0, 6])
    .range([0, innerWidth]);

  const yScale = d3.scaleLinear()
    .domain([0, maxBackoff])
    .range([innerHeight, 0]);

  // Line
  const line = d3.line()
    .x(d => xScale(d.collision))
    .y(d => yScale(d.cw))
    .curve(d3.curveMonotoneX);

  g.append("path")
    .datum(cwData)
    .attr("fill", "none")
    .attr("stroke", "#E67E22")
    .attr("stroke-width", 3)
    .attr("d", line);

  // Points
  g.selectAll("circle")
    .data(cwData)
    .join("circle")
    .attr("cx", d => xScale(d.collision))
    .attr("cy", d => yScale(d.cw))
    .attr("r", 5)
    .attr("fill", "#E67E22");

  // Labels on points
  g.selectAll(".cw-label")
    .data(cwData)
    .join("text")
    .attr("class", "cw-label")
    .attr("x", d => xScale(d.collision))
    .attr("y", d => yScale(d.cw) - 10)
    .attr("text-anchor", "middle")
    .attr("font-size", 9)
    .attr("fill", "#2C3E50")
    .text(d => d.cw);

  // Axes
  g.append("g")
    .attr("transform", `translate(0,${innerHeight})`)
    .call(d3.axisBottom(xScale).ticks(7))
    .append("text")
    .attr("x", innerWidth / 2)
    .attr("y", 30)
    .attr("fill", "#2C3E50")
    .attr("text-anchor", "middle")
    .attr("font-size", 10)
    .text("Collision Count");

  g.append("g")
    .call(d3.axisLeft(yScale).ticks(5))
    .append("text")
    .attr("transform", "rotate(-90)")
    .attr("x", -innerHeight / 2)
    .attr("y", -35)
    .attr("fill", "#2C3E50")
    .attr("text-anchor", "middle")
    .attr("font-size", 10)
    .text("CW Size");

  return svg.node();
}

// ALOHA vs CSMA/CA comparison
efficiencyComparison = {
  const width = 400;
  const height = 200;
  const margin = {top: 30, right: 20, bottom: 50, left: 50};

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("width", "100%")
    .attr("height", height)
    .style("font-family", "system-ui, sans-serif");

  svg.append("rect")
    .attr("width", width)
    .attr("height", height)
    .attr("fill", "#f8f9fa");

  svg.append("text")
    .attr("x", width / 2)
    .attr("y", 18)
    .attr("text-anchor", "middle")
    .attr("font-size", 12)
    .attr("font-weight", "bold")
    .attr("fill", "#2C3E50")
    .text("Channel Access Protocol Efficiency Comparison");

  const g = svg.append("g")
    .attr("transform", `translate(${margin.left},${margin.top})`);

  const innerWidth = width - margin.left - margin.right;
  const innerHeight = height - margin.top - margin.bottom;

  const protocols = [
    {name: "Pure ALOHA", efficiency: 18.4, color: "#E74C3C"},
    {name: "Slotted ALOHA", efficiency: 36.8, color: "#F39C12"},
    {name: "CSMA (1-pers)", efficiency: 53, color: "#3498DB"},
    {name: "CSMA/CA", efficiency: parseFloat(simulationData.stats.csmaEfficiency) || 70, color: "#16A085"}
  ];

  const xScale = d3.scaleBand()
    .domain(protocols.map(p => p.name))
    .range([0, innerWidth])
    .padding(0.3);

  const yScale = d3.scaleLinear()
    .domain([0, 100])
    .range([innerHeight, 0]);

  // Bars
  g.selectAll("rect")
    .data(protocols)
    .join("rect")
    .attr("x", d => xScale(d.name))
    .attr("y", d => yScale(d.efficiency))
    .attr("width", xScale.bandwidth())
    .attr("height", d => innerHeight - yScale(d.efficiency))
    .attr("fill", d => d.color)
    .attr("rx", 4);

  // Labels
  g.selectAll(".bar-label")
    .data(protocols)
    .join("text")
    .attr("class", "bar-label")
    .attr("x", d => xScale(d.name) + xScale.bandwidth() / 2)
    .attr("y", d => yScale(d.efficiency) - 5)
    .attr("text-anchor", "middle")
    .attr("font-size", 11)
    .attr("font-weight", "bold")
    .attr("fill", d => d.color)
    .text(d => d.efficiency.toFixed(1) + "%");

  // X axis
  g.append("g")
    .attr("transform", `translate(0,${innerHeight})`)
    .call(d3.axisBottom(xScale))
    .selectAll("text")
    .attr("font-size", 9)
    .attr("transform", "rotate(-15)")
    .attr("text-anchor", "end");

  // Y axis
  g.append("g")
    .call(d3.axisLeft(yScale).ticks(5))
    .append("text")
    .attr("transform", "rotate(-90)")
    .attr("x", -innerHeight / 2)
    .attr("y", -35)
    .attr("fill", "#2C3E50")
    .attr("text-anchor", "middle")
    .attr("font-size", 10)
    .text("Max Efficiency (%)");

  return svg.node();
}

// Node status table
nodeStatusTable = {
  const nodes = simulationData.nodes;

  return html`
    <div style="margin-top: 15px;">
      <h4 style="color: #2C3E50; margin-bottom: 10px;">Node Statistics</h4>
      <table style="width: 100%; border-collapse: collapse; font-size: 13px;">
        <thead>
          <tr style="background: #2C3E50; color: white;">
            <th style="padding: 8px; text-align: left;">Node</th>
            <th style="padding: 8px; text-align: center;">Successful TX</th>
            <th style="padding: 8px; text-align: center;">Collisions</th>
            <th style="padding: 8px; text-align: center;">Current CW</th>
            <th style="padding: 8px; text-align: center;">State</th>
          </tr>
        </thead>
        <tbody>
          ${nodes.map((n, i) => html`
            <tr style="background: ${i % 2 === 0 ? '#f8f9fa' : 'white'};">
              <td style="padding: 8px; border-bottom: 1px solid #dee2e6;">
                <span style="display: inline-block; width: 12px; height: 12px; background: ${n.color}; border-radius: 2px; margin-right: 8px;"></span>
                ${n.name}
              </td>
              <td style="padding: 8px; text-align: center; border-bottom: 1px solid #dee2e6; color: #16A085; font-weight: bold;">${n.successfulTx}</td>
              <td style="padding: 8px; text-align: center; border-bottom: 1px solid #dee2e6; color: #E74C3C; font-weight: bold;">${n.collisions}</td>
              <td style="padding: 8px; text-align: center; border-bottom: 1px solid #dee2e6;">${n.contentionWindow}</td>
              <td style="padding: 8px; text-align: center; border-bottom: 1px solid #dee2e6;">
                <span style="padding: 2px 8px; border-radius: 10px; font-size: 11px; background: ${
                  n.state === 'transmitting' ? '#16A085' :
                  n.state === 'backoff' ? '#F39C12' :
                  n.state === 'sensing' ? '#7F8C8D' : '#95a5a6'
                }; color: white;">${n.state}</span>
              </td>
            </tr>
          `)}
        </tbody>
      </table>
    </div>
  `;
}

\({cwGrowthViz}\){efficiencyComparison}

Key Metrics: - Pure ALOHA: ~18.4% max efficiency (transmit anytime, high collisions) - Slotted ALOHA: ~36.8% max efficiency (time slots reduce collisions) - CSMA/CA: 50-70%+ efficiency (carrier sensing + backoff avoids most collisions)

---

646.7 Quality of Service (QoS) for IoT

In converged networks, different traffic types have different requirements. Quality of Service (QoS) ensures critical traffic gets priority.

646.7.1 Traffic Prioritization

Priority	Traffic Type	Latency Requirement	Example
Critical	Emergency/Safety	< 10ms	Emergency stop commands
High	Real-time control	< 50ms	Robot arm control
Medium	Video/Voice	< 150ms	Security cameras
Low	Telemetry	Best effort	Temperature sensors

Question: An industrial IoT deployment needs to guarantee that emergency stop commands (100 bytes, sent every 100ms) reach controllers within 50ms even during heavy network traffic from 1000 sensor nodes sending telemetry. Which QoS implementation approach provides the BEST solution?

Explanation: Correct: Strict priority queuing with DSCP marking (C) provides deterministic latency for critical traffic. Emergency stop packets marked with DSCP EF (Expedited Forwarding) get highest priority. Network switches configured with priority queuing ensure critical queue is always serviced first - emergency packets experience minimal queuing delay (typically <1ms). Why others fail: Traffic shaping (A) doesn’t prioritize - emergency packets still wait. Bandwidth increase (B) doesn’t guarantee latency during bursts. Weighted Fair Queuing (D) guarantees bandwidth share but not strict latency.

---

646.8 Knowledge Check: Network Optimization

Question: Which network optimization techniques help reduce congestion and improve throughput in IoT networks? Select ALL that apply.

Explanation: Traffic shaping (B) smooths transmission rates to prevent congestion spikes. QoS prioritization (C) ensures critical data gets preferential treatment. Packet aggregation (D) improves efficiency - combining 10 small 50-byte readings into one 500-byte packet reduces overhead from 780 bytes to 78 bytes. Jumbo frames (A) are inappropriate for constrained IoT devices with small, frequent readings.

---

646.9 Summary

• Legacy networks required separate infrastructure for phone, video, data, and building automation - expensive and complex
• Converged networks carry all services on one IP infrastructure, reducing costs 60-75% and simplifying management
• CSMA/CA enables shared wireless medium access through carrier sensing, random backoff, and exponential backoff after collisions
• Protocol efficiency improves from 18% (Pure ALOHA) to 70%+ (CSMA/CA) through collision avoidance mechanisms
• QoS prioritization ensures critical IoT traffic (emergency commands) gets delivered within latency requirements

646.10 What’s Next

You’ve now completed the Network Mechanisms series. Continue your networking journey with:

• Layered Network Models - Understanding OSI and TCP/IP models
• IP Addressing and Subnetting - Configuring network addresses
• Routing Fundamentals - How packets find their paths

TipFurther Resources

Interactive Tools: - Cisco Packet Tracer - Network simulation tool - Wireshark - Packet analysis tool - Subnet Calculator - IP addressing practice

Video Tutorials: - Networking Fundamentals - Professor Messer - IP Addressing and Subnetting

---

NoteRelated Chapters

Deep Dives: - Networking Fundamentals - Complete networking principles for IoT - Networking Basics - Core networking concepts and terminology - Layered Models Fundamentals - OSI and TCP/IP layer models

Addressing and Configuration: - Networking Addressing and Subnetting - IPv4/IPv6 addressing, CIDR, subnet calculations - Layered Models Labs and Implementation - Hands-on IP addressing and ARP

Protocol Stack: - IoT Protocols Fundamentals - IoT-specific protocol adaptations - Transport Fundamentals - TCP and UDP in detail - Application Protocols - MQTT, CoAP, HTTP for IoT

Network Design: - Topologies Fundamentals - Star, mesh, ring, and bus topologies - Topologies Labs and Design - Practical topology design

Performance: - Routing Fundamentals - How packets find their way through networks - Transport Selection and Scenarios - Choosing TCP vs UDP