Advanced

Tutor model

i62 💰:9.4

i52 💰:7.9

🏆 i67 💰:62.5

i70 💰:125.0

i68 💰:125.0

🏆 i66 💰:75.0

i65 💰:125.0

i63 💰:62.5

i61 💰:75.0

i60 💰:9.4

i60 💰:37.5

i58 💰:62.5

i57 💰:22.5

i57 💰:37.5

i56 💰:45.0

⚡ i55 💰:11.25

i55 💰:37.5

i54 💰:62.5

i52 💰:35.0

i51 💰:37.5

i49 💰:15.0

i49 💰:62.5

i48 💰:11.3

i47 💰:7.5

i44 💰:25.0

i43 💰:37.5

i42 💰:187.5

i40 💰:5.0

i39 💰:100.0

i38 💰:37.5

i37 💰:11.0

i36 💰:187.5

i34 💰:12.5

i33 💰:37.5

i30 💰:1.0

i29 💰:1.5

i28 💰:150.0

i23 💰:20.0

i20 💰:4.0

i18 💰:1.0

i16 💰:25.0

i13 💰:1.5

Keep session private

What would you like to learn?

Override for the tutor's lesson content generation calls. Auto uses the system default (Claude Sonnet 5 for lesson text, Opus 5 for diagrams).

Lesson generation model

System default

i58 💰:18.8

i31 💰:11.0

i25 💰:31.3

Tutoring abilities

Imagine sitting by your front door staring through the peephole every five seconds just in case a delivery arrives. You would get almost nothing else done all day.

In embedded systems, microcontrollers face the exact same choice: constantly ask peripherals if they have new data, or let the hardware ring a digital doorbell.

**Cyclic polling** is a control method where the central processor periodically reads a peripheral's status register in a software loop to check if an event has occurred.

Because the central processing unit (the **CPU**, the chip's main calculation brain) executes instructions to read and compare register bits over and over, most processor cycles are wasted reading empty flags.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Polling vs Interrupt</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #f8f9fa;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      padding: 12px;
      min-height: 100%;
      user-select: none;
    }

    .controls {
      display: flex;
      gap: 8px;
      margin-bottom: 12px;
      width: 100%;
      max-width: 440px;
    }

    .btn {
      flex: 1;
      padding: 8px 12px;
      font-size: 14px;
      font-weight: 600;
      border-radius: 8px;
      border: 1px solid #e2e8f0;
      background: #ffffff;
      color: #64748b;
      cursor: pointer;
      text-align: center;
      transition: all 0.2s ease;
    }

    .btn.active {
      background: #2563eb;
      color: #ffffff;
      border-color: #2563eb;
      box-shadow: 0 2px 6px rgba(37, 99, 235, 0.25);
    }

    .stage {
      width: 100%;
      max-width: 440px;
      background: #ffffff;
      border-radius: 12px;
      border: 1px solid #e2e8f0;
      padding: 16px;
      display: flex;
      flex-direction: column;
      gap: 16px;
      position: relative;
    }

    .chips-row {
      display: flex;
      justify-content: space-between;
      align-items: center;
      position: relative;
    }

    .chip {
      width: 90px;
      height: 70px;
      background: #f1f5f9;
      border: 2px solid #cbd5e1;
      border-radius: 8px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      font-size: 13px;
      font-weight: 700;
      color: #1e2945;
      position: relative;
      z-index: 2;
    }

    .chip-cpu {
      border-color: #2563eb;
      background: #eff6ff;
    }

    .chip-sensor {
      border-color: #64748b;
    }

    .chip-sensor.active {
      border-color: #16a34a;
      background: #f0fdf4;
    }

    .chip-sub {
      font-size: 11px;
      font-weight: 500;
      color: #64748b;
      margin-top: 2px;
    }

    .bus-line {
      position: absolute;
      left: 90px;
      right: 90px;
      height: 4px;
      background: #e2e8f0;
      top: 50%;
      transform: translateY(-50%);
      z-index: 1;
    }

    .packet {
      position: absolute;
      top: 50%;
      transform: translate(-50%, -50%);
      width: 18px;
      height: 18px;
      border-radius: 50%;
      background: #2563eb;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 10px;
      color: #fff;
      transition: left 0.4s ease, opacity 0.3s ease, background 0.3s ease;
      z-index: 3;
      opacity: 0;
      left: 90px;
    }

    .timeline-box {
      background: #f8fafc;
      border-radius: 8px;
      border: 1px solid #e2e8f0;
      padding: 10px 12px;
      display: flex;
      flex-direction: column;
      gap: 6px;
    }

    .timeline-title {
      font-size: 12px;
      font-weight: 700;
      color: #64748b;
      text-transform: uppercase;
      letter-spacing: 0.5px;
      display: flex;
      justify-content: space-between;
    }

    .timeline-bar {
      height: 28px;
      background: #e2e8f0;
      border-radius: 6px;
      display: flex;
      overflow: hidden;
      gap: 2px;
      padding: 2px;
    }

    .slot {
      flex: 1;
      border-radius: 4px;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 11px;
      font-weight: 700;
      transition: all 0.3s ease;
    }

    .slot-poll { background: #fee2e2; color: #dc2626; }
    .slot-work { background: #dbeafe; color: #2563eb; }
    .slot-isr  { background: #dcfce7; color: #16a34a; }
    .slot-idle { background: #f1f5f9; color: #94a3b8; }
    .slot.highlight { outline: 2px solid #1e2945; z-index: 2; }

    .action-row {
      display: flex;
      justify-content: center;
    }

    .event-btn {
      width: 100%;
      padding: 10px;
      background: #16a34a;
      color: #ffffff;
      border: none;
      border-radius: 8px;
      font-size: 14px;
      font-weight: 700;
      cursor: pointer;
      transition: opacity 0.2s ease;
    }

    .event-btn:active {
      opacity: 0.85;
    }
  </style>
</head>
<body>

  <div class="controls">
    <button class="btn active" id="btnPoll" onclick="setMode('poll')">Polling</button>
    <button class="btn" id="btnInt" onclick="setMode('int')">Interrupt</button>
  </div>

  <div class="stage">
    <div class="chips-row">
      <div class="chip chip-cpu" id="cpuChip">
        <span>CPU</span>
        <span class="chip-sub" id="cpuState">Check</span>
      </div>

      <div class="bus-line"></div>
      <div class="packet" id="packet">?</div>

      <div class="chip chip-sensor" id="sensorChip">
        <span>Sensor</span>
        <span class="chip-sub" id="sensorState">Ready: 0</span>
      </div>
    </div>

    <div class="timeline-box">
      <div class="timeline-title">
        <span>CPU Cycles</span>
        <span id="loadLabel" style="color: #dc2626;">Wasting Cycles</span>
      </div>
      <div class="timeline-bar" id="timelineBar"></div>
    </div>

    <div class="action-row">
      <button class="event-btn" id="eventBtn" onclick="triggerEvent()">⚡ Trigger Sensor Event</button>
    </div>
  </div>

  <script>
    let mode = 'poll'; // 'poll' | 'int'
    let eventPending = false;
    let step = 0;
    let timer = null;

    const cpuState = document.getElementById('cpuState');
    const sensorState = document.getElementById('sensorState');
    const sensorChip = document.getElementById('sensorChip');
    const packet = document.getElementById('packet');
    const loadLabel = document.getElementById('loadLabel');
    const timelineBar = document.getElementById('timelineBar');

    function setMode(m) {
      mode = m;
      document.getElementById('btnPoll').classList.toggle('active', m === 'poll');
      document.getElementById('btnInt').classList.toggle('active', m === 'int');
      eventPending = false;
      step = 0;
      sensorChip.classList.remove('active');
      renderTimeline();
    }

    function triggerEvent() {
      eventPending = true;
      sensorState.textContent = 'Ready: 1';
      sensorChip.classList.add('active');
      if (mode === 'int') {
        handleInterruptNow();
      }
    }

    function renderTimeline() {
      timelineBar.innerHTML = '';
      if (mode === 'poll') {
        loadLabel.textContent = '100% Busy (Wasted)';
        loadLabel.style.color = '#dc2626';
        for (let i = 0; i < 6; i++) {
          const s = document.createElement('div');
          s.className = 'slot ' + (i === 5 && eventPending ? 'slot-isr' : 'slot-poll');
          s.textContent = (i === 5 && eventPending ? 'ISR' : 'Poll ❌');
          s.id = `slot-${i}`;
          timelineBar.appendChild(s);
        }
      } else {
        loadLabel.textContent = 'Efficient (Instant)';
        loadLabel.style.color = '#16a34a';
        for (let i = 0; i < 6; i++) {
          const s = document.createElement('div');
          s.className = 'slot slot-work';
          s.textContent = 'Work';
          s.id = `slot-${i}`;
          timelineBar.appendChild(s);
        }
      }
    }

    function tickPolling() {
      if (mode !== 'poll') return;

      const totalSlots = 6;
      const cur = step % totalSlots;
      
      for (let i = 0; i < totalSlots; i++) {
        const sl = document.getElementById(`slot-${i}`);
        if (sl) sl.classList.toggle('highlight', i === cur);
      }

      // Packet animation: CPU asks sensor
      packet.style.opacity = '1';
      packet.style.background = '#2563eb';
      packet.textContent = '?';
      packet.style.left = '32%';

      setTimeout(() => {
        packet.style.left = '68%';
        setTimeout(() => {
          if (eventPending) {
            packet.style.background = '#16a34a';
            packet.textContent = '✓';
            cpuState.textContent = 'Handle';
            sensorState.textContent = 'Ready: 0';
            sensorChip.classList.remove('active');
            const sl = document.getElementById(`slot-${cur}`);
            if (sl) {
              sl.className = 'slot slot-isr highlight';
              sl.textContent = 'ISR ✓';
            }
            eventPending = false;
          } else {
            packet.style.background = '#dc2626';
            packet.textContent = '0';
            cpuState.textContent = 'Poll ❌';
          }
          setTimeout(() => {
            packet.style.left = '32%';
            setTimeout(() => {
              packet.style.opacity = '0';
            }, 300);
          }, 300);
        }, 300);
      }, 50);

      step++;
    }

    function handleInterruptNow() {
      // Packet shoots from Sensor to CPU
      packet.style.left = '68%';
      packet.style.opacity = '1';
      packet.style.background = '#16a34a';
      packet.textContent = '⚡';

      setTimeout(() => {
        packet.style.left = '32%';
        cpuState.textContent = 'ISR ⚡';
        const cur = step % 6;
        const sl = document.getElementById(`slot-${cur}`);
        if (sl) {
          sl.className = 'slot slot-isr highlight';
          sl.textContent = 'ISR';
        }
        setTimeout(() => {
          packet.style.opacity = '0';
          sensorState.textContent = 'Ready: 0';
          sensorChip.classList.remove('active');
          eventPending = false;
          setTimeout(() => {
            cpuState.textContent = 'Work';
          }, 800);
        }, 400);
      }, 50);
    }

    function tick() {
      if (mode === 'poll') {
        tickPolling();
      } else {
        const cur = step % 6;
        for (let i = 0; i < 6; i++) {
          const sl = document.getElementById(`slot-${i}`);
          if (sl) sl.classList.toggle('highlight', i === cur);
        }
        if (!eventPending && cpuState.textContent !== 'ISR ⚡') {
          cpuState.textContent = 'Work';
        }
        step++;
      }
    }

    renderTimeline();
    timer = setInterval(tick, 1400);
  </script>
</body>
</html>

How much time elapses between an external event occurring and the processor actually responding?

**Latency** is the time delay between the moment an external hardware signal changes and the moment the CPU executes the first instruction to service that event.

In a polled system, if your main loop takes $T_{\text{loop}}$ seconds to execute, the worst-case polling latency is $T_{\text{latency}} = T_{\text{loop}}$.

If an external input pulse is shorter than $T_{\text{loop}}$, the signal can rise and fall completely between checks, causing the microcontroller to miss the event entirely.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      color: #1e293b;
      background: transparent;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      min-height: 100%;
      padding: 12px;
      gap: 12px;
    }

    .controls {
      display: flex;
      gap: 8px;
      background: #f1f5f9;
      padding: 4px;
      border-radius: 8px;
    }

    .btn {
      border: none;
      background: transparent;
      padding: 6px 16px;
      font-size: 14px;
      font-weight: 600;
      color: #64748b;
      border-radius: 6px;
      cursor: pointer;
      transition: all 0.2s ease;
    }

    .btn.active {
      background: #ffffff;
      color: #2563eb;
      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
    }

    .diagram-svg {
      width: 100%;
      max-width: 580px;
      height: auto;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      box-shadow: 0 2px 8px rgba(0,0,0,0.04);
    }

    .trace-line {
      fill: none;
      stroke: #2563eb;
      stroke-width: 2.5;
      stroke-linejoin: round;
    }

    .grid-line {
      stroke: #e2e8f0;
      stroke-width: 1;
      stroke-dasharray: 4 4;
    }

    .poll-marker {
      stroke: #64748b;
      stroke-width: 2;
    }

    .status-badge {
      font-size: 13px;
      font-weight: 700;
    }

    .play-bar {
      display: flex;
      align-items: center;
      gap: 12px;
    }

    .play-btn {
      background: #2563eb;
      color: white;
      border: none;
      border-radius: 50%;
      width: 32px;
      height: 32px;
      display: flex;
      align-items: center;
      justify-content: center;
      cursor: pointer;
      font-size: 13px;
    }
  </style>
</head>
<body>

  <div class="controls">
    <button class="btn active" id="btnPolling" onclick="setMode('polling')">Polling</button>
    <button class="btn" id="btnInterrupt" onclick="setMode('interrupt')">Interrupt</button>
  </div>

  <svg class="diagram-svg" viewBox="0 0 540 280" id="timingSvg">
    
    <line x1="120" y1="30" x2="120" y2="230" class="grid-line" />
    <line x1="240" y1="30" x2="240" y2="230" class="grid-line" />
    <line x1="360" y1="30" x2="360" y2="230" class="grid-line" />
    <line x1="480" y1="30" x2="480" y2="230" class="grid-line" />

    
    <text x="16" y="75" font-size="13" font-weight="600" fill="#475569">Input Signal</text>
    <text x="16" y="165" font-size="13" font-weight="600" fill="#475569" id="actionLabel">Poll Check</text>

    
    
    <path d="M 100 90 L 165 90 L 165 50 L 205 50 L 205 90 L 510 90" class="trace-line" />
    
    
    <rect x="165" y="45" width="40" height="50" fill="#fef3c7" rx="3" opacity="0.6" />
    <text x="185" y="40" font-size="11" font-weight="600" fill="#d97706" text-anchor="middle">Short Pulse</text>

    
    <line x1="120" y1="110" x2="240" y2="110" stroke="#94a3b8" stroke-width="1.5" />
    <line x1="120" y1="106" x2="120" y2="114" stroke="#94a3b8" stroke-width="1.5" />
    <line x1="240" y1="106" x2="240" y2="114" stroke="#94a3b8" stroke-width="1.5" />
    <text x="180" y="125" font-size="12" font-weight="600" fill="#64748b" text-anchor="middle">T_loop</text>

    
    <g id="dynamicContent"></g>

    
    <line id="timeCursor" x1="100" y1="20" x2="100" y2="240" stroke="#ef4444" stroke-width="2" stroke-dasharray="3 3" />
  </svg>

  <div class="play-bar">
    <button class="play-btn" id="playBtn" onclick="togglePlay()">▶</button>
  </div>

  <script>
    let mode = 'polling';
    let progress = 0;
    let playing = true;
    let lastTime = null;

    const cursor = document.getElementById('timeCursor');
    const dynamicContent = document.getElementById('dynamicContent');
    const actionLabel = document.getElementById('actionLabel');
    const playBtn = document.getElementById('playBtn');

    function renderMode() {
      if (mode === 'polling') {
        actionLabel.textContent = 'Poll Checks';
        dynamicContent.innerHTML = `
          
          <g transform="translate(120, 160)">
            <circle cx="0" cy="0" r="14" fill="#f1f5f9" stroke="#64748b" stroke-width="2" />
            <text x="0" y="4" font-size="10" font-weight="bold" fill="#64748b" text-anchor="middle">1</text>
            <text x="0" y="26" font-size="10" fill="#64748b" text-anchor="middle">LOW</text>
          </g>

          
          <g transform="translate(240, 160)">
            <circle cx="0" cy="0" r="14" fill="#f1f5f9" stroke="#64748b" stroke-width="2" />
            <text x="0" y="4" font-size="10" font-weight="bold" fill="#64748b" text-anchor="middle">2</text>
            <text x="0" y="26" font-size="10" fill="#64748b" text-anchor="middle">LOW</text>
          </g>

          
          <g transform="translate(360, 160)">
            <circle cx="0" cy="0" r="14" fill="#f1f5f9" stroke="#64748b" stroke-width="2" />
            <text x="0" y="4" font-size="10" font-weight="bold" fill="#64748b" text-anchor="middle">3</text>
            <text x="0" y="26" font-size="10" fill="#64748b" text-anchor="middle">LOW</text>
          </g>

          
          <g id="resultTag" opacity="0">
            <rect x="220" y="200" width="100" height="26" rx="13" fill="#fef2f2" stroke="#ef4444" stroke-width="1.5" />
            <text x="270" y="217" font-size="12" font-weight="bold" fill="#dc2626" text-anchor="middle">Missed ✕</text>
          </g>
        `;
      } else {
        actionLabel.textContent = 'Hardware ISR';
        dynamicContent.innerHTML = `
          
          <path d="M 165 90 L 165 150" stroke="#16a34a" stroke-width="2" stroke-dasharray="3 3" />
          <polygon points="165,155 160,147 170,147" fill="#16a34a" />
          
          
          <g transform="translate(165, 160)">
            <rect x="0" y="-12" width="90" height="24" rx="4" fill="#dcfce7" stroke="#16a34a" stroke-width="1.5" />
            <text x="45" y="4" font-size="11" font-weight="bold" fill="#15803d" text-anchor="middle">ISR Triggered</text>
          </g>

          
          <g id="resultTag" opacity="0">
            <rect x="220" y="200" width="100" height="26" rx="13" fill="#f0fdf4" stroke="#16a34a" stroke-width="1.5" />
            <text x="270" y="217" font-size="12" font-weight="bold" fill="#16a34a" text-anchor="middle">Captured ✓</text>
          </g>
        `;
      }
    }

    function setMode(newMode) {
      mode = newMode;
      document.getElementById('btnPolling').classList.toggle('active', mode === 'polling');
      document.getElementById('btnInterrupt').classList.toggle('active', mode === 'interrupt');
      progress = 0;
      renderMode();
    }

    function togglePlay() {
      playing = !playing;
      playBtn.textContent = playing ? '⏸' : '▶';
    }

    function animate(timestamp) {
      if (!lastTime) lastTime = timestamp;
      const dt = (timestamp - lastTime) / 1000;
      lastTime = timestamp;

      if (playing) {
        progress += dt * 0.28; // ~3.5 seconds full cycle
        if (progress > 1) {
          progress = 0;
        }
      }

      const startX = 100;
      const endX = 480;
      const curX = startX + progress * (endX - startX);
      cursor.setAttribute('x1', curX);
      cursor.setAttribute('x2', curX);

      const resultTag = document.getElementById('resultTag');
      if (resultTag) {
        const threshold = mode === 'polling' ? 245 : 170;
        resultTag.setAttribute('opacity', curX > threshold ? '1' : '0');
      }

      requestAnimationFrame(animate);
    }

    renderMode();
    playBtn.textContent = '⏸';
    requestAnimationFrame(animate);
  </script>
</body>
</html>

What if the hardware could force the processor to pause its current work the exact microsecond a signal appears?

An **interrupt** is an asynchronous signal sent by hardware directly to the CPU's interrupt controller, commanding it to suspend its main program and jump immediately to a dedicated function.

That dedicated callback function is called an **Interrupt Service Routine (ISR)**, which runs only when an event occurs and returns control back to the interrupted program once complete.

Before jumping to the ISR, the CPU performs a **context switch** by automatically saving its current position (Program Counter) and working registers onto the stack so it can resume later without data corruption.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <title>Polling vs Interrupts</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      background: #f8f9fa;
      color: #1e293b;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 12px;
      min-height: 100%;
      user-select: none;
    }

    .nav-toggle {
      display: flex;
      gap: 8px;
      margin-bottom: 12px;
      background: #e2e8f0;
      padding: 4px;
      border-radius: 8px;
    }

    .toggle-btn {
      padding: 6px 16px;
      font-size: 14px;
      font-weight: 600;
      border: none;
      border-radius: 6px;
      background: transparent;
      color: #64748b;
      cursor: pointer;
      transition: all 0.2s ease;
    }

    .toggle-btn.active {
      background: #ffffff;
      color: #2563eb;
      box-shadow: 0 1px 3px rgba(0,0,0,0.1);
    }

    .stage-container {
      width: 100%;
      max-width: 580px;
      height: 250px;
      background: #ffffff;
      border: 1px solid #cbd5e1;
      border-radius: 12px;
      position: relative;
      overflow: hidden;
      display: flex;
      flex-direction: column;
      justify-content: space-between;
      padding: 16px;
    }

    .system-grid {
      display: grid;
      grid-template-columns: 1fr 1fr 1fr;
      gap: 12px;
      height: 140px;
      position: relative;
    }

    .node {
      border: 2px solid #cbd5e1;
      border-radius: 8px;
      background: #f8fafc;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      padding: 8px;
      text-align: center;
      font-size: 13px;
      font-weight: 600;
      position: relative;
      transition: border-color 0.3s ease, background-color 0.3s ease;
    }

    .node-icon {
      font-size: 24px;
      margin-bottom: 4px;
    }

    .node.active-cpu {
      border-color: #2563eb;
      background: #eff6ff;
      color: #1e40af;
    }

    .node.active-dev {
      border-color: #059669;
      background: #ecfdf5;
      color: #065f46;
    }

    .node.active-stack {
      border-color: #d97706;
      background: #fffbeb;
      color: #92400e;
    }

    .stack-slots {
      display: flex;
      flex-direction: column-reverse;
      gap: 2px;
      width: 80%;
      margin-top: 4px;
    }

    .slot {
      height: 12px;
      background: #e2e8f0;
      border-radius: 2px;
      font-size: 9px;
      line-height: 12px;
      color: #475569;
      transition: all 0.3s ease;
    }

    .slot.filled {
      background: #f59e0b;
      color: #ffffff;
      font-weight: bold;
    }

    .signal-bus {
      position: absolute;
      top: 50%;
      left: 10%;
      right: 10%;
      height: 4px;
      background: #e2e8f0;
      transform: translateY(-50%);
      z-index: 1;
    }

    .packet {
      position: absolute;
      width: 14px;
      height: 14px;
      border-radius: 50%;
      top: -5px;
      transform: translateX(-50%);
      transition: left 0.4s ease, background 0.3s ease, opacity 0.3s ease;
      opacity: 0;
      z-index: 2;
    }

    .packet.polling {
      background: #2563eb;
    }

    .packet.interrupt {
      background: #059669;
    }

    .packet.active {
      opacity: 1;
    }

    .timeline-bar {
      display: flex;
      align-items: center;
      justify-content: space-between;
      background: #f1f5f9;
      border-radius: 8px;
      padding: 6px 12px;
      border: 1px solid #e2e8f0;
    }

    .status-badge {
      display: inline-flex;
      align-items: center;
      gap: 6px;
      font-size: 13px;
      font-weight: 700;
    }

    .badge-pill {
      background: #e0e7ff;
      color: #2563eb;
      padding: 3px 8px;
      border-radius: 12px;
      font-size: 12px;
    }

    .controls {
      display: flex;
      gap: 6px;
      align-items: center;
    }

    .ctrl-btn {
      width: 28px;
      height: 28px;
      border-radius: 50%;
      border: 1px solid #cbd5e1;
      background: #ffffff;
      color: #1e293b;
      font-size: 11px;
      display: flex;
      align-items: center;
      justify-content: center;
      cursor: pointer;
    }

    .dots {
      display: flex;
      gap: 4px;
    }

    .dot {
      width: 8px;
      height: 8px;
      border-radius: 50%;
      background: #cbd5e1;
      cursor: pointer;
      transition: background 0.2s ease;
    }

    .dot.active {
      background: #2563eb;
    }
  </style>
</head>
<body>

  <div class="nav-toggle">
    <button class="toggle-btn active" id="btnPolling">1. Polling</button>
    <button class="toggle-btn" id="btnInterrupt">2. Interrupts</button>
  </div>

  <div class="stage-container">
    <div class="system-grid">
      
      <div class="node" id="nodeCpu">
        <div class="node-icon">⚙️</div>
        <div>CPU</div>
        <div id="cpuSub" class="badge-pill" style="margin-top:4px; font-size:10px;">Idle</div>
      </div>

      
      <div class="node" id="nodeStack">
        <div class="node-icon">📚</div>
        <div>RAM Stack</div>
        <div class="stack-slots">
          <div class="slot" id="slot2">PC</div>
          <div class="slot" id="slot1">Regs</div>
        </div>
      </div>

      
      <div class="node" id="nodeDev">
        <div class="node-icon">🖲️</div>
        <div>Device</div>
        <div id="devSub" class="badge-pill" style="margin-top:4px; font-size:10px; background:#e2e8f0; color:#475569;">Ready: 0</div>
      </div>

      <div class="packet" id="packet"></div>
    </div>

    <div class="timeline-bar">
      <div class="status-badge">
        <span class="badge-pill" id="stepPill">Step 1</span>
        <span id="stepDesc">CPU checks Device status</span>
      </div>
      <div class="controls">
        <div class="dots" id="dotGroup">
          <div class="dot active"></div>
          <div class="dot"></div>
          <div class="dot"></div>
          <div class="dot"></div>
        </div>
        <button class="ctrl-btn" id="btnPrev">◀</button>
        <button class="ctrl-btn" id="btnPlay">⏸</button>
        <button class="ctrl-btn" id="btnNext">▶</button>
      </div>
    </div>
  </div>

  <script>
    const modes = {
      polling: [
        { desc: 'CPU queries Device', cpu: 'Poll (Busy)', dev: 'Ready: 0', stack: false, pos: '50%', pkt: true, type: 'polling' },
        { desc: 'Device responds: Busy', cpu: 'Poll (Busy)', dev: 'Ready: 0', stack: false, pos: '20%', pkt: true, type: 'polling' },
        { desc: 'Device event ready', cpu: 'Poll (Busy)', dev: 'Ready: 1', stack: false, pos: '80%', pkt: true, type: 'interrupt' },
        { desc: 'CPU reads Device data', cpu: 'Process Data', dev: 'Reset: 0', stack: false, pos: '20%', pkt: true, type: 'polling' }
      ],
      interrupt: [
        { desc: 'CPU runs Main Task', cpu: 'Main Program', dev: 'Idle', stack: false, pos: '20%', pkt: false, type: 'polling' },
        { desc: 'Device signals INT', cpu: 'INT Detected', dev: 'INT Line ⚡', stack: false, pos: '20%', pkt: true, type: 'interrupt' },
        { desc: 'Context switch (Push)', cpu: 'Save Context', dev: 'Wait', stack: true, pos: '50%', pkt: true, type: 'polling' },
        { desc: 'Execute ISR & Return', cpu: 'ISR Handler', dev: 'Serviced', stack: false, pos: '20%', pkt: false, type: 'polling' }
      ]
    };

    let currentMode = 'polling';
    let currentStep = 0;
    let timer = null;
    let isPlaying = true;

    const nodeCpu = document.getElementById('nodeCpu');
    const nodeDev = document.getElementById('nodeDev');
    const nodeStack = document.getElementById('nodeStack');
    const cpuSub = document.getElementById('cpuSub');
    const devSub = document.getElementById('devSub');
    const slot1 = document.getElementById('slot1');
    const slot2 = document.getElementById('slot2');
    const packet = document.getElementById('packet');
    const stepPill = document.getElementById('stepPill');
    const stepDesc = document.getElementById('stepDesc');
    const dots = document.querySelectorAll('.dot');
    const btnPlay = document.getElementById('btnPlay');

    function render() {
      const step = modes[currentMode][currentStep];
      stepPill.textContent = `Step ${currentStep + 1}`;
      stepDesc.textContent = step.desc;
      cpuSub.textContent = step.cpu;
      devSub.textContent = step.dev;

      // Active highlighting
      nodeCpu.classList.add('active-cpu');
      if (step.dev.includes('1') || step.dev.includes('INT')) {
        nodeDev.classList.add('active-dev');
      } else {
        nodeDev.classList.remove('active-dev');
      }

      if (step.stack) {
        nodeStack.classList.add('active-stack');
        slot1.classList.add('filled');
        slot2.classList.add('filled');
      } else {
        nodeStack.classList.remove('active-stack');
        slot1.classList.remove('filled');
        slot2.classList.remove('filled');
      }

      // Packet visual
      if (step.pkt) {
        packet.className = `packet active ${step.type}`;
        packet.style.left = step.pos;
      } else {
        packet.className = 'packet';
      }

      // Update dots
      dots.forEach((d, idx) => {
        d.classList.toggle('active', idx === currentStep);
      });
    }

    function setMode(mode) {
      currentMode = mode;
      currentStep = 0;
      document.getElementById('btnPolling').classList.toggle('active', mode === 'polling');
      document.getElementById('btnInterrupt').classList.toggle('active', mode === 'interrupt');
      render();
    }

    function nextStep() {
      currentStep = (currentStep + 1) % 4;
      render();
    }

    function prevStep() {
      currentStep = (currentStep - 1 + 4) % 4;
      render();
    }

    function startTimer() {
      stopTimer();
      timer = setInterval(nextStep, 2600);
      btnPlay.textContent = '⏸';
      isPlaying = true;
    }

    function stopTimer() {
      if (timer) clearInterval(timer);
      btnPlay.textContent = '▶';
      isPlaying = false;
    }

    // Event Listeners
    document.getElementById('btnPolling').addEventListener('click', () => setMode('polling'));
    document.getElementById('btnInterrupt').addEventListener('click', () => setMode('interrupt'));

    document.getElementById('btnNext').addEventListener('click', () => {
      stopTimer();
      nextStep();
    });

    document.getElementById('btnPrev').addEventListener('click', () => {
      stopTimer();
      prevStep();
    });

    btnPlay.addEventListener('click', () => {
      if (isPlaying) stopTimer();
      else startTimer();
    });

    dots.forEach((d, idx) => {
      d.addEventListener('click', () => {
        stopTimer();
        currentStep = idx;
        render();
      });
    });

    // Start playback
    render();
    startTimer();
  </script>
</body>
</html>

How do we quantify whether polling or interrupts deliver better efficiency and response speed for a real system?

## Worked Comparison: CPU Overhead and Latency

**CPU overhead** is the percentage of total processor clock cycles consumed solely by the management mechanism rather than meaningful application computation.

Let's analyze a 16 MHz microcontroller ($16 \times 10^6$ cycles/s) monitoring an emergency stop button that is pressed on average once every 10 seconds.

Under **Method A (Polling)**: The main loop executes every $1\text{ ms}$ ($1000\text{ times/second}$). Checking the input pin and branching takes 16 clock cycles each iteration.

Total polling cycles per second = $1000 \times 16 = 16{,}000\text{ cycles/s}$. $\text{Overhead} = \frac{16{,}000}{16{,}000{,}000} \times 100\% = 0.1\%$, with a worst-case latency of $1\text{ ms}$ ($1000\;\mu\text{s}$).

Under **Method B (Hardware Interrupt)**: The button triggers an ISR on a falling edge. The hardware context save takes 4 cycles, the ISR takes 20 cycles, and context restore takes 4 cycles (total 28 cycles per press).

Over 10 seconds, total cycles consumed = 28 cycles (an average of $2.8\text{ cycles/s}$). $\text{Overhead} = \frac{2.8}{16{,}000{,}000} \times 100\% = 0.0000175\%$, with a maximum latency of just $\frac{4\text{ cycles}}{16\text{ MHz}} = 0.25\;\mu\text{s}$.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <meta name="aspect-ratio" content="4:3">
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      font-family: system-ui, -apple-system, sans-serif;
      background: #ffffff;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      gap: 12px;
      width: 100%;
      min-height: 100%;
      overflow-x: hidden;
    }
    .controls {
      display: flex;
      justify-content: center;
      gap: 8px;
    }
    .btn {
      background: #2563eb;
      color: #ffffff;
      border: none;
      padding: 8px 18px;
      border-radius: 6px;
      font-size: 14px;
      font-weight: 600;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 6px;
      transition: opacity 0.2s;
    }
    .btn:hover { opacity: 0.88; }
    .btn:active { opacity: 0.75; }
    .grid {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 12px;
      width: 100%;
    }
    @media (max-width: 440px) {
      .grid { grid-template-columns: 1fr; }
    }
    .panel {
      border-radius: 8px;
      padding: 12px;
      display: flex;
      flex-direction: column;
      gap: 10px;
    }
    .panel-polling {
      background: #f8fafc;
      border: 1px solid #cbd5e1;
    }
    .panel-interrupt {
      background: #eff6ff;
      border: 1px solid #bfdbfe;
    }
    .title-row {
      display: flex;
      justify-content: space-between;
      align-items: center;
      font-weight: 700;
      font-size: 15px;
    }
    .badge {
      font-size: 11px;
      padding: 3px 7px;
      border-radius: 4px;
      font-weight: 600;
      letter-spacing: 0.5px;
      text-transform: uppercase;
    }
    .panel-polling .badge { background: #64748b; color: #fff; }
    .panel-interrupt .badge { background: #2563eb; color: #fff; }
    .vis-box {
      height: 90px;
      background: #ffffff;
      border-radius: 6px;
      border: 1px solid #e2e8f0;
      position: relative;
      overflow: hidden;
      display: flex;
      align-items: center;
      justify-content: space-around;
      padding: 8px;
    }
    .cpu-core {
      width: 44px;
      height: 44px;
      border-radius: 6px;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      font-size: 11px;
      font-weight: 700;
      transition: background-color 0.25s, box-shadow 0.25s;
    }
    .polling-cpu {
      background: #f1f5f9;
      border: 2px solid #64748b;
      color: #334155;
    }
    .polling-cpu.active {
      background: #cbd5e1;
      box-shadow: 0 0 8px rgba(100, 116, 139, 0.4);
    }
    .interrupt-cpu {
      background: #f8fafc;
      border: 2px solid #93c5fd;
      color: #1e40af;
    }
    .interrupt-cpu.active {
      background: #2563eb;
      color: #ffffff;
      border-color: #1d4ed8;
      box-shadow: 0 0 10px rgba(37, 99, 235, 0.5);
    }
    .bus-line {
      flex: 1;
      height: 4px;
      background: #e2e8f0;
      position: relative;
      margin: 0 8px;
      border-radius: 2px;
      overflow: hidden;
    }
    .bus-packet {
      position: absolute;
      top: 0;
      width: 14px;
      height: 4px;
      border-radius: 2px;
      opacity: 0;
    }
    .poll-packet {
      background: #64748b;
    }
    .irq-packet {
      background: #2563eb;
    }
    .sensor-node {
      width: 40px;
      height: 40px;
      border-radius: 50%;
      display: flex;
      align-items: center;
      justify-content: center;
      font-size: 18px;
      background: #f8fafc;
      border: 2px solid #cbd5e1;
      transition: border-color 0.2s, background-color 0.2s;
    }
    .sensor-node.triggered {
      border-color: #2563eb;
      background-color: #dbeafe;
    }
    .stats-grid {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 8px;
    }
    .stat-card {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 6px;
      padding: 6px 8px;
      text-align: center;
    }
    .stat-label {
      font-size: 11px;
      color: #64748b;
      margin-bottom: 2px;
      font-weight: 500;
    }
    .stat-val {
      font-size: 14px;
      font-weight: 700;
    }
    .stat-val-poll { color: #475569; }
    .stat-val-irq { color: #2563eb; }
  </style>
</head>
<body>
  <div class="controls">
    <button id="triggerBtn" class="btn">⚡ Trigger Event</button>
  </div>

  <div class="grid">
    
    <div class="panel panel-polling">
      <div class="title-row">
        <span>Polling</span>
        <span class="badge" id="pollBadge">Querying...</span>
      </div>
      <div class="vis-box">
        <div class="cpu-core polling-cpu" id="pollCpu">CPU</div>
        <div class="bus-line">
          <div class="bus-packet poll-packet" id="pollPkt"></div>
        </div>
        <div class="sensor-node" id="pollSensor">⏱</div>
      </div>
      <div class="stats-grid">
        <div class="stat-card">
          <div class="stat-label">CPU Load</div>
          <div class="stat-val stat-val-poll">100%</div>
        </div>
        <div class="stat-card">
          <div class="stat-label">Latency</div>
          <div class="stat-val stat-val-poll">High / Loop</div>
        </div>
      </div>
    </div>

    
    <div class="panel panel-interrupt">
      <div class="title-row">
        <span>Interrupt</span>
        <span class="badge" id="irqBadge">Idle</span>
      </div>
      <div class="vis-box">
        <div class="cpu-core interrupt-cpu" id="irqCpu">CPU</div>
        <div class="bus-line">
          <div class="bus-packet irq-packet" id="irqPkt"></div>
        </div>
        <div class="sensor-node" id="irqSensor">⚡</div>
      </div>
      <div class="stats-grid">
        <div class="stat-card">
          <div class="stat-label">Overhead</div>
          <div class="stat-val stat-val-irq">0.000018%</div>
        </div>
        <div class="stat-card">
          <div class="stat-label">Latency</div>
          <div class="stat-val stat-val-irq">0.25 µs</div>
        </div>
      </div>
    </div>
  </div>

  <script>
    const triggerBtn = document.getElementById('triggerBtn');
    const pollCpu = document.getElementById('pollCpu');
    const pollPkt = document.getElementById('pollPkt');
    const pollBadge = document.getElementById('pollBadge');
    
    const irqCpu = document.getElementById('irqCpu');
    const irqPkt = document.getElementById('irqPkt');
    const irqBadge = document.getElementById('irqBadge');
    const irqSensor = document.getElementById('irqSensor');

    // Continuous polling loop simulation
    let pollPos = 0;
    let pollDir = 1;
    setInterval(() => {
      pollPos += pollDir * 25;
      if (pollPos >= 100) {
        pollPos = 100;
        pollDir = -1;
        pollCpu.classList.add('active');
      } else if (pollPos <= 0) {
        pollPos = 0;
        pollDir = 1;
        pollCpu.classList.remove('active');
      }
      pollPkt.style.opacity = '1';
      pollPkt.style.left = `calc(${pollPos}% - 7px)`;
    }, 120);

    // Interrupt trigger handler
    let isIrqRunning = false;
    function triggerEvent() {
      if (isIrqRunning) return;
      isIrqRunning = true;
      irqSensor.classList.add('triggered');
      irqBadge.textContent = 'IRQ Active';
      irqBadge.style.background = '#dc2626';

      // Packet flows from sensor to CPU
      irqPkt.style.transition = 'none';
      irqPkt.style.left = 'calc(100% - 14px)';
      irqPkt.style.opacity = '1';

      setTimeout(() => {
        irqPkt.style.transition = 'left 0.25s ease-in-out';
        irqPkt.style.left = '0%';
      }, 30);

      setTimeout(() => {
        irqCpu.classList.add('active');
      }, 280);

      setTimeout(() => {
        irqCpu.classList.remove('active');
        irqSensor.classList.remove('triggered');
        irqBadge.textContent = 'Idle';
        irqBadge.style.background = '#2563eb';
        irqPkt.style.opacity = '0';
        isIrqRunning = false;
      }, 1000);
    }

    triggerBtn.addEventListener('click', triggerEvent);

    // Auto trigger occasionally for learning engagement
    setInterval(() => {
      if (!isIrqRunning) triggerEvent();
    }, 4500);
  </script>
</body>
</html>

Does this mean hardware interrupts are always completely cost-free?

## Pitfalls and the Interrupt Overhead Trap

A common misconception is that interrupts have zero performance penalty. Total CPU overhead scales directly with event frequency: $\text{CPU Overhead} = f_{\text{event}} \times (T_{\text{context\_switch}} + T_{\text{ISR}})$.

At extreme event frequencies, rapid context switches cause **interrupt thrashing** (or an **interrupt storm**), consuming nearly all CPU cycles and starving the main program.

For ultra-high-rate continuous data streams, cyclic polling or **Direct Memory Access (DMA)** becomes far more efficient than per-sample interrupts.

**Direct Memory Access (DMA)** is a dedicated hardware controller that transfers data directly between peripherals and RAM without CPU intervention, bypassing context-switch overhead completely.

**Direct Memory Access (DMA)** is specialized hardware that streams data blocks directly between peripherals and memory without CPU intervention, bypassing interrupt context switching entirely.

electronics

Polling versus Interrupt-Driven Control. Compare the efficiency, latency, and CPU overhead of cyclic polling against event-triggered hardware interrupts.

Processor Components & Interrupts (A-Level Computer Science)

Interrupts, Polling and Operating Systems - Advanced Level Study

Systems Architecture and Operating System Management: Interrupts and Scheduling

When teaching ELEC-11.4 to Year 13 students, emphasize quantitative evaluation over qualitative definitions. Guide students to model real-world trade-offs: calculate crossover points where high-frequency events make polling more efficient than interrupt context-switching overhead. Use visual timing traces and stack walkthroughs so students appreciate the mechanical operations (stack push/pop, vector lookup) required during hardware interrupt servicing.

Polling versus Interrupt-Driven Control

Cyclic Polling

Latency and Missed Signals