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

Every time you stream music or make a cellular call, smooth analog sound waves are chopped, rounded, and converted into streams of pure numbers.

This process is called **Pulse Code Modulation** (PCM), a technique that converts a continuous analog voltage into a sequence of binary digits.

In 1937, British engineer Alec Reeves conceived PCM to transmit noise-free speech over transatlantic cables, decades before digital computers were fast enough to make it practical.

How does an electronic circuit take an infinitely variable wave and turn it into exact ones and zeros without losing the original signal?

Converting an analog signal to a PCM stream requires three sequential operations: **sampling**, **quantization**, and **encoding**.

<!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 {
      width: 100%;
      height: 100%;
      background: #f8f9fa;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: space-between;
      padding: 10px 12px;
      user-select: none;
      -webkit-user-select: none;
    }

    .toolbar {
      display: flex;
      gap: 6px;
      width: 100%;
      max-width: 580px;
      justify-content: center;
      flex-wrap: wrap;
    }

    .step-btn {
      background: #ffffff;
      border: 1px solid #d1d5db;
      border-radius: 8px;
      padding: 6px 12px;
      font-size: 13px;
      font-weight: 600;
      color: #4b5563;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 5px;
      transition: all 0.2s ease;
    }

    .step-btn:hover {
      background: #f3f4f6;
    }

    .step-btn.active {
      background: #0284c7;
      border-color: #0284c7;
      color: #ffffff;
      box-shadow: 0 2px 6px rgba(2, 132, 199, 0.25);
    }

    .graph-card {
      width: 100%;
      max-width: 580px;
      background: #ffffff;
      border: 1px solid #e5e7eb;
      border-radius: 12px;
      padding: 8px 10px 4px 6px;
      box-shadow: 0 2px 8px rgba(0,0,0,0.04);
      display: flex;
      flex-direction: column;
      align-items: center;
    }

    svg {
      width: 100%;
      height: auto;
      display: block;
      overflow: visible;
    }

    .grid-line { stroke: #e5e7eb; stroke-width: 1; stroke-dasharray: 2 2; }
    .axis-line { stroke: #9ca3af; stroke-width: 1.5; }
    .label-lvl { font-size: 10px; fill: #6b7280; text-anchor: end; font-family: monospace; }
    .label-code { font-size: 10px; fill: #0284c7; font-weight: 700; text-anchor: start; font-family: monospace; }
    .label-t { font-size: 10px; fill: #6b7280; text-anchor: middle; font-family: monospace; }

    .signal-curve {
      fill: none;
      stroke: #94a3b8;
      stroke-width: 2.5;
      stroke-linecap: round;
      transition: opacity 0.3s ease;
    }

    .sample-stem {
      stroke: #0284c7;
      stroke-width: 2;
      stroke-dasharray: 3 2;
      transition: opacity 0.3s ease;
    }

    .sample-dot {
      fill: #0284c7;
      transition: transform 0.3s ease, opacity 0.3s ease;
    }

    .quant-dot {
      fill: #e11d48;
      stroke: #ffffff;
      stroke-width: 1.5;
      transition: opacity 0.3s ease;
    }

    .quant-err {
      stroke: #e11d48;
      stroke-width: 1.5;
      transition: opacity 0.3s ease;
    }

    .bit-badge {
      font-size: 10px;
      font-weight: bold;
      fill: #047857;
      font-family: monospace;
      text-anchor: middle;
      transition: opacity 0.3s ease;
    }

    .stream-box {
      width: 100%;
      max-width: 580px;
      background: #ffffff;
      border: 1px solid #e5e7eb;
      border-radius: 8px;
      padding: 6px 12px;
      display: flex;
      align-items: center;
      justify-content: space-between;
      box-shadow: 0 1px 3px rgba(0,0,0,0.03);
    }

    .stream-label {
      font-size: 11px;
      font-weight: 700;
      color: #64748b;
      letter-spacing: 0.5px;
    }

    .bitstream {
      font-family: "SF Mono", Monaco, Consolas, monospace;
      font-size: 12px;
      font-weight: 700;
      color: #047857;
      display: flex;
      gap: 6px;
      flex-wrap: wrap;
    }

    .bit-group {
      background: #ecfdf5;
      padding: 2px 5px;
      border-radius: 4px;
      border: 1px solid #a7f3d0;
      transition: all 0.2s;
    }

    .bit-group.dim {
      opacity: 0.2;
      background: #f1f5f9;
      border-color: #cbd5e1;
      color: #94a3b8;
    }
  </style>
</head>
<body>

  <div class="toolbar">
    <button class="step-btn active" id="btn0" onclick="setStep(0)">Overview</button>
    <button class="step-btn" id="btn1" onclick="setStep(1)">1. Sample (PAM)</button>
    <button class="step-btn" id="btn2" onclick="setStep(2)">2. Quantize</button>
    <button class="step-btn" id="btn3" onclick="setStep(3)">3. Encode (PCM)</button>
  </div>

  <div class="graph-card">
    <svg viewBox="0 0 460 210" id="pcmSvg">
      
      <g id="grid"></g>

      
      <line x1="45" y1="180" x2="420" y2="180" class="axis-line"/>
      <line x1="45" y1="20" x2="45" y2="180" class="axis-line"/>

      
      <path id="analogWave" class="signal-curve" d=""/>

      
      <g id="elementsGroup"></g>
    </svg>
  </div>

  <div class="stream-box">
    <span class="stream-label">PCM BITSTREAM:</span>
    <div class="bitstream" id="streamDisplay"></div>
  </div>

  <script>
    const levels = 8; // 3-bit (0..7)
    const yMax = 30;  // SVG top padding
    const yMin = 170; // SVG bottom level
    const yStep = (yMin - yMax) / (levels - 1);

    const xStart = 55;
    const xEnd = 410;
    const sampleCount = 9;
    const xStep = (xEnd - xStart) / (sampleCount - 1);

    // Mathematical continuous analog function: A * sin(wt) + offset
    function analogFn(x) {
      const normX = (x - xStart) / (xEnd - xStart);
      const angle = normX * Math.PI * 2 - 0.3;
      const normY = 0.5 + 0.42 * Math.sin(angle) - 0.08 * Math.cos(angle * 2);
      return yMin - normY * (yMin - yMax);
    }

    // Initialize Background Grid & Quantization Codes
    const grid = document.getElementById('grid');
    const binCodes = ['000', '001', '010', '011', '100', '101', '110', '111'];
    
    for (let i = 0; i < levels; i++) {
      const y = yMin - i * yStep;
      grid.innerHTML += `
        <line x1="45" y1="${y}" x2="420" y2="${y}" class="grid-line"/>
        <text x="40" y="${y + 3.5}" class="label-lvl">${i}</text>
        <text x="424" y="${y + 3.5}" class="label-code">${binCodes[i]}</text>
      `;
    }

    // Generate Continuous Wave Path
    let wavePath = `M ${xStart} ${analogFn(xStart)}`;
    for (let x = xStart; x <= xEnd; x += 3) {
      wavePath += ` L ${x} ${analogFn(x)}`;
    }
    document.getElementById('analogWave').setAttribute('d', wavePath);

    // Compute Sample Data
    const samples = [];
    for (let i = 0; i < sampleCount; i++) {
      const x = xStart + i * xStep;
      const exactY = analogFn(x);
      
      // Calculate closest quantization level (0 to 7)
      const lvlRatio = (yMin - exactY) / (yMin - yMax);
      let quantLevel = Math.round(lvlRatio * (levels - 1));
      quantLevel = Math.max(0, Math.min(levels - 1, quantLevel));
      const quantY = yMin - quantLevel * yStep;

      samples.push({
        idx: i,
        x: x,
        exactY: exactY,
        quantY: quantY,
        level: quantLevel,
        code: binCodes[quantLevel]
      });
    }

    // Render Dynamic Elements inside SVG
    const group = document.getElementById('elementsGroup');
    const streamDisplay = document.getElementById('streamDisplay');

    function renderStage(step) {
      group.innerHTML = '';
      streamDisplay.innerHTML = '';

      const analog = document.getElementById('analogWave');
      analog.style.opacity = (step === 3) ? '0.2' : (step === 0 ? '0.7' : '1');

      samples.forEach((s) => {
        // Sample stems & dots
        const showSample = (step === 0 || step === 1 || step === 2 || step === 3);
        const showQuant = (step === 0 || step === 2 || step === 3);
        const showCode = (step === 0 || step === 3);

        let html = '';

        if (showSample) {
          html += `
            <line x1="${s.x}" y1="180" x2="${s.x}" y2="${s.exactY}" class="sample-stem"/>
            <circle cx="${s.x}" cy="${s.exactY}" r="3.5" class="sample-dot"/>
            <text x="${s.x}" y="195" class="label-t">T${s.idx}</text>
          `;
        }

        if (showQuant) {
          // Quantization error line + discrete point
          html += `
            <line x1="${s.x}" y1="${s.exactY}" x2="${s.x}" y2="${s.quantY}" class="quant-err"/>
            <circle cx="${s.x}" cy="${s.quantY}" r="4" class="quant-dot"/>
          `;
        }

        if (showCode) {
          html += `
            <text x="${s.x}" y="${s.quantY - 8}" class="bit-badge">${s.code}</text>
          `;
        }

        group.innerHTML += html;

        // Bitstream badge
        const isDim = (step === 1 || step === 2);
        streamDisplay.innerHTML += `
          <span class="bit-group ${isDim ? 'dim' : ''}">${showCode ? s.code : '...'}</span>
        `;
      });
    }

    let currentStep = 0;
    function setStep(idx) {
      currentStep = idx;
      for (let i = 0; i <= 3; i++) {
        document.getElementById('btn' + i).classList.toggle('active', i === idx);
      }
      renderStage(idx);
    }

    // Initial render
    setStep(0);
  </script>
</body>
</html>

**Sampling** converts a continuous-time signal into a discrete-time signal (**Pulse Amplitude Modulation** / PAM) at uniform intervals $T_s = \frac{1}{f_s}$.

According to the **Nyquist Sampling Criterion**, the sampling rate must satisfy $f_s \ge 2f_{\text{max}}$ to prevent **aliasing distortion**.

To digitize these pulse amplitudes, we must restrict an infinite range of possible voltages into a finite set of allowed levels.

An $n$-bit analog-to-digital converter divides the total input voltage range $V_{\text{range}} = V_{\text{max}} - V_{\text{min}}$ into $L = 2^n$ distinct **quantization levels**.

The voltage difference between any two adjacent levels is the **step size** (or resolution), denoted by $\Delta$ (delta): $$\Delta = \frac{V_{\text{max}} - V_{\text{min}}}{2^n} = \frac{V_{\text{range}}}{L}$$

<!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 {
      width: 100%;
      background: #f8f9fa;
      font-family: system-ui, -apple-system, sans-serif;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 10px;
    }
    .controls {
      display: flex;
      gap: 8px;
      justify-content: center;
      width: 100%;
      max-width: 540px;
    }
    .btn {
      background: #ffffff;
      border: 1px solid #d1d5db;
      padding: 6px 14px;
      border-radius: 8px;
      font-size: 13px;
      font-weight: 600;
      color: #4b5563;
      cursor: pointer;
      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
      transition: all 0.2s ease;
    }
    .btn.active {
      background: #22b7ff;
      border-color: #0ea5e9;
      color: #ffffff;
      box-shadow: 0 2px 4px rgba(34,183,255,0.25);
    }
    .chart-container {
      width: 100%;
      max-width: 540px;
      background: #ffffff;
      border: 1px solid #e5e7eb;
      border-radius: 12px;
      padding: 8px 6px;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
      position: relative;
    }
    svg {
      width: 100%;
      height: auto;
      display: block;
      overflow: visible;
    }
    .grid-line { stroke: #e5e7eb; stroke-width: 1; stroke-dasharray: 2,3; }
    .level-text { font-size: 10px; fill: #6b7280; font-family: monospace; }
    .analog-curve { fill: none; stroke: #94a3b8; stroke-width: 2.5; stroke-linecap: round; }
    .quant-line { fill: none; stroke: #22b7ff; stroke-width: 2.5; }
    .sample-stem { stroke: #cbd5e1; stroke-width: 1.5; stroke-dasharray: 2,2; }
    .sample-dot { fill: #64748b; transition: r 0.2s; }
    .quant-dot { fill: #0284c7; stroke: #ffffff; stroke-width: 1.5; }
    .error-bar { stroke: #ef4444; stroke-width: 2; stroke-linecap: round; }
    .code-box {
      display: flex;
      justify-content: space-around;
      width: 100%;
      max-width: 540px;
      padding: 6px 12px;
      background: #ffffff;
      border: 1px solid #e5e7eb;
      border-radius: 8px;
      font-family: monospace;
      font-size: 13px;
      font-weight: 700;
      color: #0284c7;
    }
    .code-item {
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 2px;
    }
    .code-label {
      font-size: 9px;
      color: #9ca3af;
      font-family: system-ui, sans-serif;
    }
  </style>
</head>
<body>

  <div class="controls">
    <button id="btn2" class="btn" onclick="setLevels(2)">2-bit (L=4)</button>
    <button id="btn3" class="btn active" onclick="setLevels(3)">3-bit (L=8)</button>
  </div>

  <div class="chart-container">
    <svg id="pcmSvg" viewBox="0 0 500 240"></svg>
  </div>

  <div class="code-box" id="codeStream"></div>

  <script>
    let currentBits = 3;
    const numSamples = 7;
    const svg = document.getElementById('pcmSvg');
    const codeStream = document.getElementById('codeStream');

    const margin = { top: 20, right: 30, bottom: 25, left: 55 };
    const width = 500;
    const height = 240;
    const plotW = width - margin.left - margin.right;
    const plotH = height - margin.top - margin.bottom;

    // Analog wave: normal sine mapped from 0.1 to 0.9 of full dynamic range
    function analogValue(tNorm) {
      return 0.5 + 0.38 * Math.sin(tNorm * Math.PI * 1.7 + 0.3);
    }

    function render() {
      const L = Math.pow(2, currentBits);
      const deltaH = plotH / (L - 1);
      svg.innerHTML = '';
      codeStream.innerHTML = '';

      // Draw horizontal Quantisation levels & binary labels
      for (let i = 0; i < L; i++) {
        const y = margin.top + plotH - i * deltaH;
        const binCode = i.toString(2).padStart(currentBits, '0');

        // Line
        const line = document.createElementNS('http://www.w3.org/2000/svg', 'line');
        line.setAttribute('x1', margin.left);
        line.setAttribute('y1', y);
        line.setAttribute('x2', margin.left + plotW);
        line.setAttribute('y2', y);
        line.setAttribute('class', 'grid-line');
        svg.appendChild(line);

        // Binary level label
        const txt = document.createElementNS('http://www.w3.org/2000/svg', 'text');
        txt.setAttribute('x', margin.left - 8);
        txt.setAttribute('y', y + 3.5);
        txt.setAttribute('text-anchor', 'end');
        txt.setAttribute('class', 'level-text');
        txt.textContent = binCode;
        svg.appendChild(txt);
      }

      // Draw Step Size (Δ) indicator on left
      const dY1 = margin.top + plotH - deltaH;
      const dY2 = margin.top + plotH;
      const deltaX = 14;
      const deltaPath = `M ${deltaX+5} ${dY1} L ${deltaX} ${dY1} L ${deltaX} ${dY2} L ${deltaX+5} ${dY2} M ${deltaX} ${(dY1+dY2)/2} L ${deltaX-4} ${(dY1+dY2)/2}`;
      const dLine = document.createElementNS('http://www.w3.org/2000/svg', 'path');
      dLine.setAttribute('d', deltaPath);
      dLine.setAttribute('stroke', '#0284c7');
      dLine.setAttribute('stroke-width', '1.5');
      dLine.setAttribute('fill', 'none');
      svg.appendChild(dLine);

      const dTxt = document.createElementNS('http://www.w3.org/2000/svg', 'text');
      dTxt.setAttribute('x', deltaX + 8);
      dTxt.setAttribute('y', (dY1 + dY2) / 2 + 4);
      dTxt.setAttribute('font-size', '11px');
      dTxt.setAttribute('font-weight', 'bold');
      dTxt.setAttribute('fill', '#0284c7');
      dTxt.textContent = 'Δ';
      svg.appendChild(dTxt);

      // Draw Analog Curve (smooth path)
      let pathD = '';
      for (let px = 0; px <= plotW; px += 2) {
        const tNorm = px / plotW;
        const v = analogValue(tNorm);
        const y = margin.top + plotH - (v * plotH);
        pathD += (px === 0 ? 'M' : 'L') + ` ${margin.left + px} ${y}`;
      }
      const curve = document.createElementNS('http://www.w3.org/2000/svg', 'path');
      curve.setAttribute('d', pathD);
      curve.setAttribute('class', 'analog-curve');
      svg.appendChild(curve);

      // Process sample points
      const samplePoints = [];
      for (let s = 0; s < numSamples; s++) {
        const tNorm = (s + 0.5) / numSamples;
        const x = margin.left + tNorm * plotW;
        const vAnalog = analogValue(tNorm);
        const yAnalog = margin.top + plotH - (vAnalog * plotH);

        // Nearest quantisation level
        const levelIndex = Math.round(vAnalog * (L - 1));
        const yQuant = margin.top + plotH - (levelIndex * deltaH);
        const binCode = levelIndex.toString(2).padStart(currentBits, '0');

        samplePoints.push({ x, yAnalog, yQuant, binCode, s });

        // Stem from baseline to sample
        const stem = document.createElementNS('http://www.w3.org/2000/svg', 'line');
        stem.setAttribute('x1', x);
        stem.setAttribute('y1', margin.top + plotH);
        stem.setAttribute('x2', x);
        stem.setAttribute('y2', yAnalog);
        stem.setAttribute('class', 'sample-stem');
        svg.appendChild(stem);

        // Quantisation rounding error arrow/line
        const errLine = document.createElementNS('http://www.w3.org/2000/svg', 'line');
        errLine.setAttribute('x1', x);
        errLine.setAttribute('y1', yAnalog);
        errLine.setAttribute('x2', x);
        errLine.setAttribute('y2', yQuant);
        errLine.setAttribute('class', 'error-bar');
        svg.appendChild(errLine);

        // Analog Sample dot
        const dotA = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
        dotA.setAttribute('cx', x);
        dotA.setAttribute('cy', yAnalog);
        dotA.setAttribute('r', '3.5');
        dotA.setAttribute('class', 'sample-dot');
        svg.appendChild(dotA);

        // Quantised level dot
        const dotQ = document.createElementNS('http://www.w3.org/2000/svg', 'circle');
        dotQ.setAttribute('cx', x);
        dotQ.setAttribute('cy', yQuant);
        dotQ.setAttribute('r', '4.5');
        dotQ.setAttribute('class', 'quant-dot');
        svg.appendChild(dotQ);

        // Sample time label at bottom
        const tTxt = document.createElementNS('http://www.w3.org/2000/svg', 'text');
        tTxt.setAttribute('x', x);
        tTxt.setAttribute('y', margin.top + plotH + 16);
        tTxt.setAttribute('text-anchor', 'middle');
        tTxt.setAttribute('class', 'level-text');
        tTxt.textContent = `t${s+1}`;
        svg.appendChild(tTxt);

        // Add to PCM output stream below
        const item = document.createElement('div');
        item.className = 'code-item';
        item.innerHTML = `<span class="code-label">t${s+1}</span><span>${binCode}</span>`;
        codeStream.appendChild(item);
      }
    }

    function setLevels(bits) {
      currentBits = bits;
      document.getElementById('btn2').classList.toggle('active', bits === 2);
      document.getElementById('btn3').classList.toggle('active', bits === 3);
      render();
    }

    render();
  </script>
</body>
</html>

Because incoming voltages rarely land exactly on an allowed level, the quantizer rounds each sample to the nearest quantization level.

This rounding introduces an unavoidable difference between the true input voltage $V_{\text{in}}$ and the quantizer output $V_q$, known as **quantization error** ($e_q = V_q - V_{\text{in}}$).

What does this rounding behavior look like when plotted as a continuous function of input voltage?

Plotting output code against input voltage produces a characteristic **staircase transfer graph**.

<!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: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      user-select: none;
    }

    .dashboard {
      width: 100%;
      max-width: 580px;
      display: grid;
      grid-template-columns: repeat(3, 1fr);
      gap: 8px;
      margin-bottom: 8px;
    }

    .badge {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 6px 8px;
      text-align: center;
      box-shadow: 0 1px 3px rgba(0,0,0,0.04);
    }

    .badge-label {
      font-size: 11px;
      color: #64748b;
      font-weight: 600;
      text-transform: uppercase;
      letter-spacing: 0.5px;
    }

    .badge-value {
      font-size: 16px;
      font-weight: 700;
      color: #1e2945;
      font-variant-numeric: tabular-nums;
    }

    .badge-value.code {
      color: #0284c7;
      letter-spacing: 1px;
      font-family: monospace;
    }

    .badge-value.error {
      color: #d97706;
    }

    .graph-container {
      width: 100%;
      max-width: 580px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 12px;
      padding: 8px;
      box-shadow: 0 2px 6px rgba(0,0,0,0.04);
      position: relative;
    }

    svg {
      width: 100%;
      height: auto;
      display: block;
      overflow: visible;
    }

    .controls {
      width: 100%;
      max-width: 580px;
      display: flex;
      align-items: center;
      gap: 12px;
      margin-top: 10px;
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 10px;
      padding: 8px 14px;
    }

    .slider-label {
      font-size: 13px;
      font-weight: 600;
      color: #475569;
      white-space: nowrap;
    }

    input[type=range] {
      flex: 1;
      accent-color: #0284c7;
      cursor: pointer;
      height: 6px;
    }

    .btn {
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      border-radius: 6px;
      padding: 4px 10px;
      font-size: 12px;
      font-weight: 600;
      color: #334155;
      cursor: pointer;
      display: flex;
      align-items: center;
      gap: 4px;
    }
    .btn:hover { background: #e2e8f0; }
    .btn.active { background: #0284c7; color: #fff; border-color: #0284c7; }
  </style>
</head>
<body>

  <div class="dashboard">
    <div class="badge">
      <div class="badge-label">Input V<sub>in</sub></div>
      <div class="badge-value" id="valVin">3.50 V</div>
    </div>
    <div class="badge">
      <div class="badge-label">PCM Code</div>
      <div class="badge-value code" id="valCode">011</div>
    </div>
    <div class="badge">
      <div class="badge-label">Error e<sub>q</sub></div>
      <div class="badge-value error" id="valErr">-0.50 V</div>
    </div>
  </div>

  <div class="graph-container">
    <svg viewBox="0 0 460 300" id="quantSvg">
      
      <g stroke="#f1f5f9" stroke-width="1" id="gridGroup"></g>

      
      <line x1="50" y1="250" x2="430" y2="250" stroke="#94a3b8" stroke-width="1.5" />
      <line x1="50" y1="250" x2="50" y2="20" stroke="#94a3b8" stroke-width="1.5" />

      
      <line x1="42" y1="221.25" x2="42" y2="192.5" stroke="#0284c7" stroke-width="2" />
      <line x1="38" y1="221.25" x2="46" y2="221.25" stroke="#0284c7" stroke-width="1.5" />
      <line x1="38" y1="192.5" x2="46" y2="192.5" stroke="#0284c7" stroke-width="1.5" />
      <text x="34" y="210" fill="#0284c7" font-size="11" font-weight="bold" text-anchor="end">Δ</text>

      
      <line x1="50" y1="250" x2="410" y2="20" stroke="#cbd5e1" stroke-width="1.5" stroke-dasharray="4,4" />

      
      <path id="staircasePath" fill="none" stroke="#0284c7" stroke-width="2.5" stroke-linejoin="round" />

      
      <g id="axisLabelsGroup" font-size="10" fill="#64748b" font-family="monospace"></g>

      
      
      <line id="vinLine" x1="50" y1="250" x2="50" y2="250" stroke="#94a3b8" stroke-width="1" stroke-dasharray="2,2" />
      
      
      <line id="vqLine" x1="50" y1="250" x2="50" y2="250" stroke="#0284c7" stroke-width="1" stroke-dasharray="2,2" />

      
      <line id="errorBar" x1="50" y1="250" x2="50" y2="250" stroke="#d97706" stroke-width="3" stroke-linecap="round" />

      
      <circle id="markerStair" cx="50" cy="250" r="5" fill="#0284c7" stroke="#ffffff" stroke-width="2" />

      
      <circle id="markerRamp" cx="50" cy="250" r="4" fill="#64748b" />

      
      <text x="430" y="265" fill="#64748b" font-size="11" font-weight="600" text-anchor="end">Input V<sub>in</sub></text>
      <text x="50" y="14" fill="#64748b" font-size="11" font-weight="600" text-anchor="start">Code / V<sub>q</sub></text>
    </svg>
  </div>

  <div class="controls">
    <span class="slider-label">V<sub>in</sub></span>
    <input type="range" id="vinSlider" min="0" max="8" step="0.05" value="3.5">
    <button class="btn" id="playBtn">▶ Auto</button>
  </div>

  <script>
    const levels = 8;
    const vMax = 8;
    const x0 = 50, y0 = 250, xSpan = 360, ySpan = 230;

    const codes = ["000","001","010","011","100","101","110","111"];
    const gridGroup = document.getElementById('gridGroup');
    const axisLabelsGroup = document.getElementById('axisLabelsGroup');
    const staircasePath = document.getElementById('staircasePath');

    // Build Static Grid & Axis Labels
    let gridHtml = '';
    let labelHtml = '';

    for (let i = 0; i <= levels; i++) {
      const gx = x0 + (i / levels) * xSpan;
      const gy = y0 - (i / levels) * ySpan;
      gridHtml += `<line x1="${gx}" y1="${y0}" x2="${gx}" y2="${y0 - ySpan}" />`;
      gridHtml += `<line x1="${x0}" y1="${gy}" x2="${x0 + xSpan}" y2="${gy}" />`;

      // X tick
      labelHtml += `<text x="${gx}" y="${y0 + 14}" text-anchor="middle">${i}V</text>`;
    }

    for (let i = 0; i < levels; i++) {
      const gy = y0 - ((i + 0.5) / levels) * ySpan;
      // Code label on Y axis
      labelHtml += `<text x="${x0 - 8}" y="${gy + 3.5}" text-anchor="end">${codes[i]}</text>`;
    }

    gridGroup.innerHTML = gridHtml;
    axisLabelsGroup.innerHTML = labelHtml;

    // Draw Staircase (Mid-Rise uniform quantizer: thresholds at integers 1,2,3...7)
    // Level k active for Vin in [k, k+1), represented at quantized value k + 0.5
    let pathD = `M ${x0} ${y0 - (0.5 / levels) * ySpan}`;
    for (let i = 0; i < levels; i++) {
      const xStart = x0 + (i / levels) * xSpan;
      const xEnd = x0 + ((i + 1) / levels) * xSpan;
      const yVal = y0 - ((i + 0.5) / levels) * ySpan;
      if (i > 0) {
        pathD += ` L ${xStart} ${yVal}`;
      }
      pathD += ` L ${xEnd} ${yVal}`;
    }
    staircasePath.setAttribute('d', pathD);

    // Dynamic Elements
    const vinSlider = document.getElementById('vinSlider');
    const valVin = document.getElementById('valVin');
    const valCode = document.getElementById('valCode');
    const valErr = document.getElementById('valErr');

    const vinLine = document.getElementById('vinLine');
    const vqLine = document.getElementById('vqLine');
    const errorBar = document.getElementById('errorBar');
    const markerStair = document.getElementById('markerStair');
    const markerRamp = document.getElementById('markerRamp');
    const playBtn = document.getElementById('playBtn');

    function update(vin) {
      vin = Math.max(0, Math.min(7.99, vin));
      const qIndex = Math.min(7, Math.floor(vin));
      const vq = qIndex + 0.5; // mid-rise representation level (Δ = 1V)
      const err = vq - vin; // quantization error: -0.5 <= eq <= +0.5

      // UI readouts
      valVin.textContent = vin.toFixed(2) + ' V';
      valCode.textContent = codes[qIndex];
      const sign = err >= 0 ? '+' : '';
      valErr.textContent = sign + err.toFixed(2) + ' V';

      // Pixel positions
      const pxVin = x0 + (vin / levels) * xSpan;
      const pyVin = y0 - (vin / levels) * ySpan;
      const pyVq = y0 - (vq / levels) * ySpan;

      // Update staircase marker
      markerStair.setAttribute('cx', pxVin);
      markerStair.setAttribute('cy', pyVq);

      // Update ramp marker
      markerRamp.setAttribute('cx', pxVin);
      markerRamp.setAttribute('cy', pyVin);

      // Vertical track line from axis up to stair
      vinLine.setAttribute('x1', pxVin);
      vinLine.setAttribute('y1', y0);
      vinLine.setAttribute('x2', pxVin);
      vinLine.setAttribute('y2', Math.min(pyVin, pyVq));

      // Horizontal code line
      vqLine.setAttribute('x1', x0);
      vqLine.setAttribute('y1', pyVq);
      vqLine.setAttribute('x2', pxVin);
      vqLine.setAttribute('y2', pyVq);

      // Error bar between ramp and staircase level
      errorBar.setAttribute('x1', pxVin);
      errorBar.setAttribute('y1', pyVin);
      errorBar.setAttribute('x2', pxVin);
      errorBar.setAttribute('y2', pyVq);
    }

    vinSlider.addEventListener('input', (e) => {
      stopAuto();
      update(parseFloat(e.target.value));
    });

    let autoTimer = null;
    let autoDirection = 1;

    function startAuto() {
      playBtn.classList.add('active');
      playBtn.textContent = '⏸ Pause';
      autoTimer = setInterval(() => {
        let v = parseFloat(vinSlider.value) + 0.04 * autoDirection;
        if (v >= 7.9) { v = 7.9; autoDirection = -1; }
        if (v <= 0.1) { v = 0.1; autoDirection = 1; }
        vinSlider.value = v.toFixed(2);
        update(v);
      }, 30);
    }

    function stopAuto() {
      if (autoTimer) {
        clearInterval(autoTimer);
        autoTimer = null;
      }
      playBtn.classList.remove('active');
      playBtn.textContent = '▶ Auto';
    }

    playBtn.addEventListener('click', () => {
      if (autoTimer) stopAuto();
      else startAuto();
    });

    // Initial render
    update(parseFloat(vinSlider.value));
  </script>
</body>
</html>

In a uniform mid-tread or mid-rise quantizer, the maximum rounding error is always exactly half a step: $$-\frac{\Delta}{2} \le e_q \le +\frac{\Delta}{2}$$

Now let's trace an entire analog waveform through sampling, quantization, and binary encoding step by step.

## Worked Example: From Waveform to Binary Stream

Consider an analog signal sampled at 4 successive points: $t_1 = 1.3\text{ V}$, $t_2 = 4.8\text{ V}$, $t_3 = 6.9\text{ V}$, and $t_4 = 3.1\text{ V}$ in an 8-level ($3\text{-bit}$) system with a $0\text{ to }8\text{ V}$ range ($\\Delta = 1.0\text{ V}$).

<!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>Pulse Code Modulation & Quantisation</title>
  <style>
    * { box-sizing: border-box; margin: 0; padding: 0; }
    body {
      width: 100%;
      min-height: 100%;
      background: #ffffff;
      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 10px 12px;
      user-select: none;
    }

    .toolbar {
      display: flex;
      align-items: center;
      justify-content: center;
      gap: 6px;
      flex-wrap: wrap;
      margin-bottom: 8px;
      width: 100%;
      max-width: 580px;
    }

    .btn {
      background: #f1f5f9;
      border: 1px solid #cbd5e1;
      border-radius: 6px;
      padding: 5px 10px;
      font-size: 13px;
      font-weight: 600;
      color: #475569;
      cursor: pointer;
      display: inline-flex;
      align-items: center;
      gap: 4px;
      transition: background 0.2s, color 0.2s, border-color 0.2s;
    }

    .btn:hover {
      background: #e2e8f0;
      color: #1e2945;
    }

    .btn.active {
      background: #22b7ff;
      border-color: #0284c7;
      color: #ffffff;
      box-shadow: 0 1px 3px rgba(34, 183, 255, 0.3);
    }

    .diagram-svg {
      width: 100%;
      max-width: 580px;
      height: auto;
      background: #ffffff;
      border-radius: 8px;
      overflow: visible;
    }

    /* SVG typography & styling */
    .grid-line { stroke: #e2e8f0; stroke-width: 1; stroke-dasharray: 2 2; }
    .axis-line { stroke: #94a3b8; stroke-width: 1.5; }
    .level-label { font-size: 10.5px; fill: #64748b; font-family: ui-monospace, monospace; }
    .axis-title { font-size: 11px; fill: #475569; font-weight: 600; }
    .time-label { font-size: 11.5px; fill: #1e2945; font-weight: 600; text-anchor: middle; }
    
    .analog-curve { fill: none; stroke: #94a3b8; stroke-width: 2.5; stroke-linecap: round; }
    .sample-stem { stroke-width: 1.5; stroke-dasharray: 3 3; transition: stroke 0.3s; }
    .quant-line { stroke-width: 2; stroke-linecap: round; transition: opacity 0.3s; }
    .error-bracket { stroke-width: 1.5; }
    
    .stream-container {
      width: 100%;
      max-width: 580px;
      margin-top: 6px;
      display: grid;
      grid-template-columns: repeat(4, 1fr);
      gap: 6px;
    }

    .word-card {
      background: #f8fafc;
      border: 1px solid #e2e8f0;
      border-radius: 6px;
      padding: 6px 4px;
      text-align: center;
      transition: all 0.25s ease;
    }

    .word-card.active {
      background: #eff6ff;
      border-color: #22b7ff;
      box-shadow: 0 0 0 1px #22b7ff;
    }

    .word-card .time-tag {
      font-size: 11px;
      font-weight: 700;
      color: #64748b;
      margin-bottom: 2px;
    }

    .word-card.active .time-tag {
      color: #0284c7;
    }

    .word-card .bits {
      font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
      font-size: 15px;
      font-weight: 800;
      letter-spacing: 2px;
      color: #0f172a;
    }

    .word-card.active .bits {
      color: #0284c7;
    }

    .word-card .meta {
      font-size: 10.5px;
      color: #64748b;
      margin-top: 2px;
    }
  </style>
</head>
<body>

  <div class="toolbar">
    <button class="btn active" id="btn-all" onclick="selectStep(-1)">Overview</button>
    <button class="btn" id="btn-0" onclick="selectStep(0)"><i>t</i>₁ (1.3V)</button>
    <button class="btn" id="btn-1" onclick="selectStep(1)"><i>t</i>₂ (4.8V)</button>
    <button class="btn" id="btn-2" onclick="selectStep(2)"><i>t</i>₃ (6.9V)</button>
    <button class="btn" id="btn-3" onclick="selectStep(3)"><i>t</i>₄ (3.1V)</button>
    <button class="btn" id="btn-play" onclick="togglePlay()">▶ Auto</button>
  </div>

  <svg class="diagram-svg" viewBox="0 0 540 250">
    
    
    <g id="grid">
      
      <line x1="72" y1="30" x2="510" y2="30" class="grid-line" />
      <text x="66" y="33" text-anchor="end" class="level-label">111 (7V)</text>

      
      <line x1="72" y1="55" x2="510" y2="55" class="grid-line" />
      <text x="66" y="58" text-anchor="end" class="level-label">110 (6V)</text>

      
      <line x1="72" y1="80" x2="510" y2="80" class="grid-line" />
      <text x="66" y="83" text-anchor="end" class="level-label">101 (5V)</text>

      
      <line x1="72" y1="105" x2="510" y2="105" class="grid-line" />
      <text x="66" y="108" text-anchor="end" class="level-label">100 (4V)</text>

      
      <line x1="72" y1="130" x2="510" y2="130" class="grid-line" />
      <text x="66" y="133" text-anchor="end" class="level-label">011 (3V)</text>

      
      <line x1="72" y1="155" x2="510" y2="155" class="grid-line" />
      <text x="66" y="158" text-anchor="end" class="level-label">010 (2V)</text>

      
      <line x1="72" y1="180" x2="510" y2="180" class="grid-line" />
      <text x="66" y="183" text-anchor="end" class="level-label">001 (1V)</text>

      
      <line x1="72" y1="205" x2="510" y2="205" class="grid-line" />
      <text x="66" y="208" text-anchor="end" class="level-label">000 (0V)</text>
    </g>

    
    <line x1="72" y1="18" x2="72" y2="215" class="axis-line" />
    <line x1="72" y1="205" x2="520" y2="205" class="axis-line" />
    
    
    <text x="135" y="222" class="time-label">t₁</text>
    <text x="245" y="222" class="time-label">t₂</text>
    <text x="355" y="222" class="time-label">t₃</text>
    <text x="465" y="222" class="time-label">t₄</text>

    
    <path id="analogPath" class="analog-curve" d="
      M 80,195
      C 105,190 115,180 135,172.5
      C 175,145 205,95 245,85
      C 290,75 315,35 355,32.5
      C 395,30 425,120 465,127.5
      C 485,131 498,150 515,165
    " />

    
    <g id="samples-layer"></g>
  </svg>

  
  <div class="stream-container">
    <div class="word-card" id="card-0" onclick="selectStep(0)">
      <div class="time-tag">Sample t₁</div>
      <div class="bits">001</div>
      <div class="meta">1.3V → 1V</div>
    </div>
    <div class="word-card" id="card-1" onclick="selectStep(1)">
      <div class="time-tag">Sample t₂</div>
      <div class="bits">101</div>
      <div class="meta">4.8V → 5V</div>
    </div>
    <div class="word-card" id="card-2" onclick="selectStep(2)">
      <div class="time-tag">Sample t₃</div>
      <div class="bits">111</div>
      <div class="meta">6.9V → 7V</div>
    </div>
    <div class="word-card" id="card-3" onclick="selectStep(3)">
      <div class="time-tag">Sample t₄</div>
      <div class="bits">011</div>
      <div class="meta">3.1V → 3V</div>
    </div>
  </div>

  <script>
    const samples = [
      { x: 135, val: 1.3, qVal: 1, bits: '001', qLevel: 1 },
      { x: 245, val: 4.8, qVal: 5, bits: '101', qLevel: 5 },
      { x: 355, val: 6.9, qVal: 7, bits: '111', qLevel: 7 },
      { x: 465, val: 3.1, qVal: 3, bits: '011', qLevel: 3 }
    ];

    function getY(voltage) {
      return 205 - (voltage / 7.0) * 175;
    }

    const layer = document.getElementById('samples-layer');
    let currentStep = -1;
    let timer = null;

    function renderSamples() {
      let html = '';
      samples.forEach((s, idx) => {
        const yAnalog = getY(s.val);
        const yQuant = getY(s.qVal);
        const isSelected = (currentStep === -1 || currentStep === idx);
        const isSolo = (currentStep === idx);

        const stemColor = isSelected ? '#38bdf8' : '#cbd5e1';
        const analogDotColor = isSelected ? '#0284c7' : '#94a3b8';
        const quantDotColor = isSelected ? '#10b981' : '#cbd5e1';
        const snapLineColor = isSelected ? '#f59e0b' : 'transparent';
        const opacity = (currentStep === -1 || isSolo) ? '1' : '0.25';

        html += `
          <g opacity="${opacity}" style="transition: opacity 0.3s ease;">
            
            <line x1="${s.x}" y1="${Math.min(yAnalog, yQuant)}" x2="${s.x}" y2="205" stroke="${stemColor}" class="sample-stem" />
            
            
            <line x1="${s.x}" y1="${yAnalog}" x2="${s.x}" y2="${yQuant}" stroke="${snapLineColor}" stroke-width="2.5" />
            
            
            <line x1="${s.x - 14}" y1="${yQuant}" x2="${s.x + 14}" y2="${yQuant}" stroke="${isSelected ? '#10b981' : '#94a3b8'}" stroke-width="2.5" stroke-linecap="round" />
            
            
            <circle cx="${s.x}" cy="${yAnalog}" r="4" fill="${analogDotColor}" stroke="#ffffff" stroke-width="1.5" />
            
            
            <circle cx="${s.x}" cy="${yQuant}" r="4.5" fill="${quantDotColor}" stroke="#ffffff" stroke-width="1.5" />

            
            ${isSolo ? `
              <rect x="${s.x + 8}" y="${yAnalog - 12}" width="54" height="24" rx="4" fill="#1e2945" />
              <text x="${s.x + 35}" y="${yAnalog + 4}" font-size="10.5" fill="#ffffff" font-weight="700" text-anchor="middle">
                ${s.val}V→${s.qVal}V
              </text>
            ` : ''}
          </g>
        `;
      });
      layer.innerHTML = html;

      // Update Toolbar buttons
      document.getElementById('btn-all').classList.toggle('active', currentStep === -1);
      for (let i = 0; i < 4; i++) {
        document.getElementById(`btn-${i}`).classList.toggle('active', currentStep === i);
        document.getElementById(`card-${i}`).classList.toggle('active', currentStep === -1 || currentStep === i);
      }
    }

    function selectStep(step) {
      currentStep = step;
      renderSamples();
    }

    function togglePlay() {
      const pBtn = document.getElementById('btn-play');
      if (timer) {
        clearInterval(timer);
        timer = null;
        pBtn.textContent = '▶ Auto';
        pBtn.classList.remove('active');
      } else {
        pBtn.textContent = '⏸ Pause';
        pBtn.classList.add('active');
        let next = (currentStep + 1) % 4;
        selectStep(next);
        timer = setInterval(() => {
          currentStep = (currentStep + 1) % 4;
          selectStep(currentStep);
        }, 3200);
      }
    }

    // Initial render
    renderSamples();
  </script>
</body>
</html>

**Binary encoding** converts each discrete quantisation level index ($0$ to $L-1$) into an $n$-bit binary word (e.g., $3\text{ bits} \rightarrow 000_2 \text{ to } 111_2$), which is transmitted serially as digital pulses.

Transmitted in sequence from first sample to last, the output bitstream is `001101111011`.

A common mistake on exams is assuming that increasing the sampling frequency reduces quantization noise. Sampling faster gives finer time resolution, but only adding more **quantization bits** ($n$) reduces the voltage step size $\Delta$.

## The Complete PCM Transmission Architecture

In a standard PCM transmitter, an **Anti-Aliasing Low-Pass Filter** first eliminates input frequencies above $f_{\text{max}}$ before a **Sample-and-Hold Circuit** captures uniform PAM samples.

The samples pass into a **Quantiser** and then a **Binary Encoder**, which converts each level into a serial stream of binary pulses.

This bitstream travels across a **Digital Transmission Channel**, where **Regenerative Repeaters** periodically reshape and clean the pulses to eliminate channel noise.

At the destination, a **Binary Decoder** reads the bitstream, a **Digital-to-Analogue Converter** (DAC) reconstructs voltage steps, and a **Reconstruction Low-Pass Filter** restores the smooth original analog wave.

Each additional bit doubles the number of levels and cuts the step size in half, improving the **signal-to-quantization-noise ratio** (SQNR) by approximately $6.02\text{ dB}$.

A standard PCM transmission system architecture consists of: **Anti-Aliasing Low-Pass Filter** $\rightarrow$ **Sample-and-Hold Circuit** (PAM) $\rightarrow$ Quantiser $\rightarrow$ **Binary Encoder** $\rightarrow$ **Digital Transmission Channel** with **Regenerative Repeaters** $\rightarrow$ **Binary Decoder** $\rightarrow$ **Digital-to-Analogue Converter** (DAC) $\rightarrow$ **Reconstruction Low-Pass Filter**.

In this chain, **regenerative repeaters** clean up pulse distortions along the transmission medium before the receiver decodes the bitstream and reconstructs the smooth analog waveform.

electronics

Pulse Code Modulation Encoding and Quantisation Graphs. Produce and interpret graphs illustrating sampling, uniform quantisation levels, step sizes, and binary code generation.

A Level Electronics: Pulse Modulation and Digital Communications

Understanding Pulse Code Modulation (PCM) in Digital Telecommunications

A-Level Communication Systems: Pulse Code Modulation & Analogue-to-Digital Conversion

Pedagogical strategy focuses on scaffolded graphical analysis: start with an analogue sine wave, overlay regular time intervals to demonstrate sampling (PAM), superimpose horizontal grid steps to demonstrate quantisation rounding, and explicitly write the binary binary code below each vertical time slice. This visual progression removes abstraction and directly links the mathematical formulas ($L = 2^n$, $\Delta V = \frac{V_{pp}}{2^n}$, $R_b = n f_s$) to their geometric counterparts on the graphs.

Pulse Code Modulation Encoding and Quantisation Graphs

The Three Stages of PCM

Uniform Quantization and Step Size