679  Protocol State Machine Playground

Interactive Protocol Behavior Visualization

679.1 Protocol State Machine Playground

NoteLearning Objectives

By using this interactive tool, you will be able to:

• Visualize how protocols transition between states
• Understand message acknowledgment patterns
• Explore error scenarios and recovery
• Compare QoS behavior across MQTT, CoAP, and BLE

TipFor Beginners: What is a State Machine?

A state machine describes how a system behaves - what “state” it’s in and how it responds to events.

Concept	Example
State	Connected, Disconnected, Waiting
Transition	An event that causes state change
Action	What happens during a transition

Real Example: A light switch has two states (ON/OFF) and one transition (flip).

IoT protocols are more complex - they handle connections, messages, errors, and acknowledgments through carefully designed state machines.

---

679.2 Select Protocol

viewof selectedProtocol = Inputs.radio(
  ["MQTT", "CoAP", "BLE"],
  {label: "Protocol:", value: "MQTT"}
)

viewof scenarioType = Inputs.select(
  ["Normal Connection", "Message Exchange", "Error & Recovery", "QoS Comparison"],
  {label: "Scenario:", value: "Normal Connection"}
)

---

679.3 State Machine Visualization

protocolStates = ({
  "MQTT": {
    states: [
      {id: "disconnected", name: "Disconnected", x: 100, y: 200, color: "#E74C3C"},
      {id: "connecting", name: "Connecting", x: 300, y: 100, color: "#F39C12"},
      {id: "connected", name: "Connected", x: 500, y: 200, color: "#27AE60"},
      {id: "subscribing", name: "Subscribing", x: 500, y: 350, color: "#3498DB"},
      {id: "publishing", name: "Publishing", x: 300, y: 350, color: "#9B59B6"}
    ],
    transitions: [
      {from: "disconnected", to: "connecting", label: "CONNECT", event: "connect"},
      {from: "connecting", to: "connected", label: "CONNACK", event: "connack"},
      {from: "connecting", to: "disconnected", label: "TIMEOUT", event: "timeout"},
      {from: "connected", to: "subscribing", label: "SUBSCRIBE", event: "subscribe"},
      {from: "subscribing", to: "connected", label: "SUBACK", event: "suback"},
      {from: "connected", to: "publishing", label: "PUBLISH", event: "publish"},
      {from: "publishing", to: "connected", label: "PUBACK (QoS1)", event: "puback"},
      {from: "connected", to: "disconnected", label: "DISCONNECT", event: "disconnect"}
    ],
    initial: "disconnected"
  },
  "CoAP": {
    states: [
      {id: "idle", name: "Idle", x: 100, y: 200, color: "#7F8C8D"},
      {id: "waiting", name: "Waiting for ACK", x: 300, y: 100, color: "#F39C12"},
      {id: "confirmed", name: "Confirmed", x: 500, y: 200, color: "#27AE60"},
      {id: "observing", name: "Observing", x: 500, y: 350, color: "#3498DB"},
      {id: "retrying", name: "Retrying", x: 300, y: 350, color: "#E74C3C"}
    ],
    transitions: [
      {from: "idle", to: "waiting", label: "CON Request", event: "con_request"},
      {from: "waiting", to: "confirmed", label: "ACK", event: "ack"},
      {from: "waiting", to: "retrying", label: "TIMEOUT", event: "timeout"},
      {from: "retrying", to: "waiting", label: "Retransmit", event: "retransmit"},
      {from: "retrying", to: "idle", label: "Max Retries", event: "max_retries"},
      {from: "confirmed", to: "idle", label: "Complete", event: "complete"},
      {from: "idle", to: "observing", label: "GET + Observe", event: "observe"},
      {from: "observing", to: "idle", label: "Cancel", event: "cancel"}
    ],
    initial: "idle"
  },
  "BLE": {
    states: [
      {id: "standby", name: "Standby", x: 100, y: 200, color: "#7F8C8D"},
      {id: "advertising", name: "Advertising", x: 300, y: 100, color: "#F39C12"},
      {id: "scanning", name: "Scanning", x: 300, y: 300, color: "#3498DB"},
      {id: "initiating", name: "Initiating", x: 500, y: 200, color: "#9B59B6"},
      {id: "connected", name: "Connected", x: 650, y: 200, color: "#27AE60"}
    ],
    transitions: [
      {from: "standby", to: "advertising", label: "Start Adv", event: "start_adv"},
      {from: "standby", to: "scanning", label: "Start Scan", event: "start_scan"},
      {from: "advertising", to: "standby", label: "Stop", event: "stop_adv"},
      {from: "advertising", to: "connected", label: "Connection Request", event: "conn_req"},
      {from: "scanning", to: "standby", label: "Stop", event: "stop_scan"},
      {from: "scanning", to: "initiating", label: "Found Device", event: "found"},
      {from: "initiating", to: "connected", label: "Connected", event: "connected"},
      {from: "initiating", to: "standby", label: "Timeout", event: "timeout"},
      {from: "connected", to: "standby", label: "Disconnect", event: "disconnect"}
    ],
    initial: "standby"
  }
})

currentProtocol = protocolStates[selectedProtocol]

d3 = require("d3@7")

// State machine simulation
mutable currentState = currentProtocol.initial
mutable messageLog = []
mutable stepCount = 0

// Reset when protocol changes
{
  selectedProtocol;
  mutable currentState = currentProtocol.initial;
  mutable messageLog = [];
  mutable stepCount = 0;
}

availableTransitions = currentProtocol.transitions.filter(t => t.from === currentState)

// Trigger a transition
triggerTransition = (event) => {
  const transition = currentProtocol.transitions.find(t => t.from === currentState && t.event === event);
  if (transition) {
    mutable messageLog = [...messageLog, {
      step: ++mutable stepCount,
      from: transition.from,
      to: transition.to,
      label: transition.label,
      time: new Date().toLocaleTimeString()
    }];
    mutable currentState = transition.to;
  }
}

// Draw state machine
{
  const width = 750;
  const height = 450;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("style", "max-width: 100%; height: auto; background: #f8f9fa; border-radius: 12px;");

  // Draw transitions (arrows)
  currentProtocol.transitions.forEach(t => {
    const fromState = currentProtocol.states.find(s => s.id === t.from);
    const toState = currentProtocol.states.find(s => s.id === t.to);

    if (fromState && toState) {
      // Calculate path
      const dx = toState.x - fromState.x;
      const dy = toState.y - fromState.y;
      const len = Math.sqrt(dx * dx + dy * dy);

      // Offset for start/end (avoid overlapping circle)
      const startX = fromState.x + (dx / len) * 45;
      const startY = fromState.y + (dy / len) * 45;
      const endX = toState.x - (dx / len) * 45;
      const endY = toState.y - (dy / len) * 45;

      // Curve control point
      const midX = (startX + endX) / 2;
      const midY = (startY + endY) / 2;
      const perpX = -dy / len * 30;
      const perpY = dx / len * 30;

      const path = `M ${startX} ${startY} Q ${midX + perpX} ${midY + perpY} ${endX} ${endY}`;

      svg.append("path")
        .attr("d", path)
        .attr("fill", "none")
        .attr("stroke", "#BDC3C7")
        .attr("stroke-width", 2)
        .attr("marker-end", "url(#arrowhead)");

      // Transition label
      svg.append("text")
        .attr("x", midX + perpX * 0.7)
        .attr("y", midY + perpY * 0.7)
        .attr("text-anchor", "middle")
        .attr("font-size", "10px")
        .attr("fill", "#7F8C8D")
        .text(t.label);
    }
  });

  // Arrow marker
  svg.append("defs").append("marker")
    .attr("id", "arrowhead")
    .attr("viewBox", "0 -5 10 10")
    .attr("refX", 8)
    .attr("refY", 0)
    .attr("markerWidth", 6)
    .attr("markerHeight", 6)
    .attr("orient", "auto")
    .append("path")
    .attr("d", "M0,-5L10,0L0,5")
    .attr("fill", "#7F8C8D");

  // Draw states (circles)
  currentProtocol.states.forEach(state => {
    const isActive = state.id === currentState;

    // State circle
    svg.append("circle")
      .attr("cx", state.x)
      .attr("cy", state.y)
      .attr("r", isActive ? 42 : 38)
      .attr("fill", isActive ? state.color : "#ECF0F1")
      .attr("stroke", state.color)
      .attr("stroke-width", isActive ? 4 : 2)
      .style("transition", "all 0.3s ease");

    // State label
    svg.append("text")
      .attr("x", state.x)
      .attr("y", state.y + 5)
      .attr("text-anchor", "middle")
      .attr("font-size", "12px")
      .attr("font-weight", isActive ? "bold" : "normal")
      .attr("fill", isActive ? "white" : "#2C3E50")
      .text(state.name);
  });

  // Title
  svg.append("text")
    .attr("x", width / 2)
    .attr("y", 25)
    .attr("text-anchor", "middle")
    .attr("font-size", "16px")
    .attr("font-weight", "bold")
    .attr("fill", "#2C3E50")
    .text(`${selectedProtocol} State Machine`);

  return svg.node();
}

---

679.4 Controls

html`
<div style="background: #E8F4FD; padding: 20px; border-radius: 12px; margin: 20px 0;">
  <h4 style="margin-top: 0; color: #2C3E50;">Current State: <span style="color: ${currentProtocol.states.find(s => s.id === currentState)?.color || '#2C3E50'};">${currentProtocol.states.find(s => s.id === currentState)?.name || currentState}</span></h4>

  <div style="margin: 15px 0;">
    <strong>Available Actions:</strong>
  </div>

  <div style="display: flex; flex-wrap: wrap; gap: 10px;">
    ${availableTransitions.length > 0 ? availableTransitions.map(t => html`
      <button
        onclick=${() => triggerTransition(t.event)}
        style="background: linear-gradient(135deg, #16A085 0%, #27AE60 100%);
               color: white; border: none; padding: 10px 20px;
               border-radius: 6px; cursor: pointer; font-weight: 500;
               transition: transform 0.2s ease;">
        ${t.label}
      </button>
    `) : html`<span style="color: #7F8C8D;">No actions available (end state)</span>`}
  </div>

  <div style="margin-top: 15px;">
    <button
      onclick=${() => {
        mutable currentState = currentProtocol.initial;
        mutable messageLog = [];
        mutable stepCount = 0;
      }}
      style="background: #E74C3C; color: white; border: none;
             padding: 8px 15px; border-radius: 4px; cursor: pointer;">
      Reset
    </button>
  </div>
</div>
`

---

679.5 Message Log

html`
<div style="background: #2C3E50; color: #ECF0F1; padding: 15px; border-radius: 8px;
            font-family: monospace; font-size: 13px; max-height: 200px; overflow-y: auto;">
  <div style="color: #7F8C8D; margin-bottom: 10px;">--- Message Log ---</div>
  ${messageLog.length === 0 ?
    html`<div style="color: #7F8C8D;">Click buttons above to trigger state transitions...</div>` :
    messageLog.map(m => html`
      <div style="margin: 5px 0; padding: 5px; background: #34495E; border-radius: 4px;">
        <span style="color: #F39C12;">[${m.step}]</span>
        <span style="color: #3498DB;">${m.time}</span>
        <span style="color: #27AE60;">${m.from}</span>
        <span style="color: #7F8C8D;">→</span>
        <span style="color: #27AE60;">${m.to}</span>
        <span style="color: #E74C3C;">(${m.label})</span>
      </div>
    `)
  }
</div>
`

---

679.6 Scenario Walkthroughs

NoteMQTT: Normal Connection Flow

Step-by-step walkthrough:

1. Client → Broker: CONNECT
   • Client sends connection request with client ID, credentials, clean session flag
   • State: Disconnected → Connecting
2. Broker → Client: CONNACK
   • Broker accepts or rejects with return code
   • Return codes: 0=Accepted, 1=Bad protocol, 2=ID rejected, 4=Bad credentials, 5=Not authorized
   • State: Connecting → Connected
3. Client → Broker: SUBSCRIBE
   • Client subscribes to topic filter with desired QoS
   • State: Connected → Subscribing
4. Broker → Client: SUBACK
   • Broker confirms subscription with granted QoS
   • May grant lower QoS than requested
   • State: Subscribing → Connected
5. Client → Broker: PUBLISH (QoS 1)
   • Client publishes message to topic
   • State: Connected → Publishing
6. Broker → Client: PUBACK
   • Broker confirms receipt (QoS 1 only)
   • State: Publishing → Connected

Try it: Click CONNECT → CONNACK → SUBSCRIBE → SUBACK → PUBLISH → PUBACK

NoteCoAP: Confirmable Request with Retry

Step-by-step walkthrough:

1. Client sends CON (Confirmable) Request
   • Request includes Message ID for matching
   • State: Idle → Waiting for ACK
2. Normal case: ACK received
   • Server responds with ACK + same Message ID
   • Response piggybacked or separate
   • State: Waiting → Confirmed → Idle
3. Timeout case: No ACK received
   • Wait RESPONSE_TIMEOUT (default 2s)
   • State: Waiting → Retrying
4. Retransmission
   • Resend with exponential backoff
   • Max 4 retransmissions by default
   • State: Retrying → Waiting
5. Max retries exceeded
   • Report failure to application
   • State: Retrying → Idle

Key difference from MQTT: CoAP is RESTful (request/response) vs MQTT’s pub/sub model.

NoteBLE: Connection Establishment

Step-by-step walkthrough:

1. Peripheral: Start Advertising
   • Broadcast advertisement packets on 3 channels
   • Contains device name, services, flags
   • State: Standby → Advertising
2. Central: Start Scanning
   • Listen for advertisements
   • State: Standby → Scanning
3. Central: Found Device
   • Parse advertisement, check services
   • State: Scanning → Initiating
4. Central: Send Connection Request
   • CONNECT_IND packet with parameters
   • Includes connection interval, timeout
5. Both: Connected
   • Begin connection events
   • Can exchange data via GATT
   • State: Initiating → Connected / Advertising → Connected

Key concept: BLE uses roles (Central/Peripheral) that determine who initiates connections.

---

679.7 QoS Comparison

qosComparison = [
  {
    protocol: "MQTT",
    qos0: "At most once (fire and forget)",
    qos1: "At least once (with PUBACK)",
    qos2: "Exactly once (4-way handshake)",
    useCase: "QoS 0 for telemetry, QoS 1 for commands, QoS 2 for billing"
  },
  {
    protocol: "CoAP",
    qos0: "NON (Non-confirmable)",
    qos1: "CON (Confirmable with ACK)",
    qos2: "N/A",
    useCase: "NON for frequent updates, CON for critical data"
  },
  {
    protocol: "BLE",
    qos0: "Write Without Response",
    qos1: "Write With Response",
    qos2: "Reliable Write (queued)",
    useCase: "Without response for streaming, with response for config"
  }
]

html`
<div style="overflow-x: auto; margin: 20px 0;">
  <table style="width: 100%; border-collapse: collapse; min-width: 600px;">
    <thead>
      <tr style="background: #2C3E50; color: white;">
        <th style="padding: 12px; text-align: left;">Protocol</th>
        <th style="padding: 12px; text-align: left;">No Guarantee</th>
        <th style="padding: 12px; text-align: left;">Acknowledged</th>
        <th style="padding: 12px; text-align: left;">Exactly Once</th>
        <th style="padding: 12px; text-align: left;">Use Case</th>
      </tr>
    </thead>
    <tbody>
      ${qosComparison.map(q => html`
        <tr style="border-bottom: 1px solid #E5E5E5;">
          <td style="padding: 12px; font-weight: bold; color: #16A085;">${q.protocol}</td>
          <td style="padding: 12px;">${q.qos0}</td>
          <td style="padding: 12px;">${q.qos1}</td>
          <td style="padding: 12px;">${q.qos2}</td>
          <td style="padding: 12px; font-size: 12px; color: #666;">${q.useCase}</td>
        </tr>
      `)}
    </tbody>
  </table>
</div>
`

---

679.8 Knowledge Check

NoteQuestion 1

In MQTT, what happens if a client publishes with QoS 1 but doesn’t receive a PUBACK?

1. The message is lost
2. The client retransmits until PUBACK received
3. The broker ignores duplicates
4. Both B and C

TipAnswer

D) Both B and C - QoS 1 guarantees “at least once” delivery. The client retransmits on timeout, and the broker tracks Message IDs to handle duplicates. This can result in duplicate delivery if the original was received but PUBACK was lost.

NoteQuestion 2

Why does CoAP use UDP instead of TCP?

1. UDP is more secure
2. UDP has lower overhead for constrained devices
3. TCP doesn’t work on wireless networks
4. UDP supports larger messages

TipAnswer

B) UDP has lower overhead for constrained devices - TCP’s connection establishment, congestion control, and guaranteed delivery add overhead. CoAP implements its own lightweight reliability (CON/ACK) when needed, making it more suitable for IoT devices with limited resources.

NoteQuestion 3

In BLE, which device initiates the connection?

1. Always the Peripheral
2. Always the Central
3. Either device can initiate
4. The device with stronger signal

TipAnswer

B) Always the Central - In BLE’s connection model, Peripherals advertise and Centrals scan. Only Centrals can initiate connections. This is a fundamental asymmetry in BLE’s design. (Note: Some devices can switch roles.)

---

679.9 Related Resources

• MQTT Message Flow - Detailed MQTT visualization
• BLE State Machine - BLE connection details
• CoAP Messages - CoAP request/response
• Protocol Comparison Simulator - Compare protocols
• Discussion Prompts - Protocol debate topics