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 hooking a test lead to an unknown circuit, flipping on your oscilloscope, and seeing nothing but a blurry green smudge or a clipped horizontal bar. To turn that chaos into a clear, measurable waveform, you only need to master two core controls: vertical sensitivity and horizontal sweep speed.

Every oscilloscope screen displays a precision grid called a **graticule**, which is divided into standardized major squares called **divisions** (div).

<!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%;
      font-family: system-ui, -apple-system, sans-serif;
      background: transparent;
      color: #1e2945;
      display: flex;
      flex-direction: column;
      align-items: center;
      padding: 8px;
    }
    .scope-container {
      width: 100%;
      max-width: 500px;
      display: flex;
      flex-direction: column;
      gap: 10px;
    }
    .display-screen {
      position: relative;
      width: 100%;
      aspect-ratio: 10 / 8;
      background: #0f172a;
      border-radius: 12px;
      overflow: hidden;
      box-shadow: inset 0 0 20px rgba(0, 0, 0, 0.8);
    }
    svg {
      width: 100%;
      height: 100%;
      display: block;
    }
    .grid-line {
      stroke: #1e3a5f;
      stroke-width: 1;
    }
    .grid-axis {
      stroke: #2d5a88;
      stroke-width: 1.5;
    }
    .grid-sub {
      stroke: #1e3a5f;
      stroke-width: 1;
    }
    .trace {
      fill: none;
      stroke: #00f2ff;
      stroke-width: 2.5;
      stroke-linecap: round;
      stroke-linejoin: round;
      filter: drop-shadow(0 0 4px rgba(0, 242, 255, 0.6));
      transition: d 0.3s ease;
    }
    .dim-overlay {
      position: absolute;
      top: 8px;
      left: 8px;
      right: 8px;
      display: flex;
      justify-content: space-between;
      pointer-events: none;
    }
    .badge {
      background: rgba(255, 255, 255, 0.92);
      color: #1e2945;
      font-size: 13px;
      font-weight: 700;
      padding: 4px 8px;
      border-radius: 6px;
      box-shadow: 0 2px 6px rgba(0, 0, 0, 0.25);
    }
    .controls {
      display: flex;
      flex-direction: column;
      gap: 8px;
      width: 100%;
    }
    .control-row {
      display: flex;
      align-items: center;
      justify-content: space-between;
      gap: 8px;
      background: #f1f5f9;
      padding: 6px 10px;
      border-radius: 8px;
    }
    .control-label {
      font-size: 13px;
      font-weight: 700;
      color: #1e2945;
      min-width: 90px;
    }
    .btn-group {
      display: flex;
      gap: 6px;
      flex: 1;
      justify-content: flex-end;
    }
    .btn-step {
      background: #ffffff;
      border: 1px solid #cbd5e1;
      color: #1e2945;
      padding: 5px 10px;
      border-radius: 6px;
      font-size: 13px;
      font-weight: 600;
      cursor: pointer;
      user-select: none;
      transition: all 0.2s ease;
    }
    .btn-step.active {
      background: #0f172a;
      color: #00f2ff;
      border-color: #0f172a;
      box-shadow: 0 0 6px rgba(0, 242, 255, 0.3);
    }
  </style>
</head>
<body>

<div class="scope-container">
  <div class="display-screen">
    <svg id="scopeSvg" viewBox="0 0 500 400" preserveAspectRatio="none">
      <defs>
        <pattern id="graticule" width="50" height="50" patternUnits="userSpaceOnUse">
          <path d="M 50 0 L 0 0 0 50" fill="none" class="grid-line" />
        </pattern>
      </defs>
      
      
      <rect width="500" height="400" fill="url(#graticule)" />
      
      
      
      <line x1="250" y1="0" x2="250" y2="400" class="grid-axis" />
      
      <line x1="0" y1="200" x2="500" y2="200" class="grid-axis" />
      
      
      <g class="grid-sub" id="ticks"></g>
      
      
      <path id="waveTrace" class="trace" d="" />
    </svg>

    <div class="dim-overlay">
      <div class="badge" id="vBadge">2.0 V/div</div>
      <div class="badge" id="tBadge">1.0 ms/div</div>
    </div>
  </div>

  <div class="controls">
    <div class="control-row">
      <span class="control-label">Y-Scale (V/div)</span>
      <div class="btn-group" id="vButtons">
        <button class="btn-step" data-val="1">1 V</button>
        <button class="btn-step active" data-val="2">2 V</button>
        <button class="btn-step" data-val="4">4 V</button>
      </div>
    </div>
    
    <div class="control-row">
      <span class="control-label">X-Scale (Time/div)</span>
      <div class="btn-group" id="tButtons">
        <button class="btn-step" data-val="0.5">0.5 ms</button>
        <button class="btn-step active" data-val="1">1.0 ms</button>
        <button class="btn-step" data-val="2">2.0 ms</button>
      </div>
    </div>
  </div>
</div>

<script>
  // Draw graticule tick marks
  const ticksGroup = document.getElementById('ticks');
  let ticksHtml = '';
  // Horizontal axis ticks (every 10px = 0.2 div)
  for (let x = 10; x < 500; x += 10) {
    if (x % 50 !== 0) {
      ticksHtml += `<line x1="${x}" y1="197" x2="${x}" y2="203" />`;
    }
  }
  // Vertical axis ticks
  for (let y = 10; y < 400; y += 10) {
    if (y % 50 !== 0) {
      ticksHtml += `<line x1="247" y1="${y}" x2="253" y2="${y}" />`;
    }
  }
  ticksGroup.innerHTML = ticksHtml;

  // Signal properties: Vpk = 3.6V (7.2V pk-pk), T = 2.0ms (500Hz)
  const V_PK = 3.6;
  const T_PERIOD_MS = 2.0;

  let vDiv = 2;   // Volts per division
  let tDiv = 1;   // ms per division

  const waveTrace = document.getElementById('waveTrace');
  const vBadge = document.getElementById('vBadge');
  const tBadge = document.getElementById('tBadge');

  function renderWave() {
    // 500px = 10 divs -> 50px/div
    // 400px = 8 divs -> 50px/div
    // Y center = 200px (0V)
    const points = [];
    const stepPx = 2; // sample resolution
    
    for (let px = 0; px <= 500; px += stepPx) {
      const divX = (px - 250) / 50; // divs from center
      const timeMs = divX * tDiv;
      const voltage = V_PK * Math.sin((2 * Math.PI * timeMs) / T_PERIOD_MS);
      const divY = voltage / vDiv;
      const py = 200 - (divY * 50);
      points.push(`${px.toFixed(1)},${py.toFixed(1)}`);
    }

    waveTrace.setAttribute('d', 'M ' + points.join(' L '));
    vBadge.textContent = `${vDiv.toFixed(vDiv % 1 === 0 ? 1 : 1)} V/div`;
    tBadge.textContent = `${tDiv.toFixed(tDiv % 1 === 0 ? 1 : 1)} ms/div`;
  }

  // Event Listeners for V/div
  document.querySelectorAll('#vButtons .btn-step').forEach(btn => {
    btn.addEventListener('click', () => {
      document.querySelectorAll('#vButtons .btn-step').forEach(b => b.classList.remove('active'));
      btn.classList.add('active');
      vDiv = parseFloat(btn.getAttribute('data-val'));
      renderWave();
    });
  });

  // Event Listeners for Time/div
  document.querySelectorAll('#tButtons .btn-step').forEach(btn => {
    btn.addEventListener('click', () => {
      document.querySelectorAll('#tButtons .btn-step').forEach(b => b.classList.remove('active'));
      btn.classList.add('active');
      tDiv = parseFloat(btn.getAttribute('data-val'));
      renderWave();
    });
  });

  renderWave();
</script>

</body>
</html>

How do we scale the height of the signal so it fills the screen without clipping?

## Vertical Sensitivity: Volts per Division

The **Volts per division (V/div)** dial acts like a vertical zoom lens by setting the voltage represented by each vertical grid square. Adjusting this dial does not change the circuit's actual voltage; it only changes how tall the trace looks on screen.

To calculate the **peak-to-peak voltage** ($V_{pp}$), which is the total vertical potential difference from the wave's lowest trough to its highest crest, multiply the vertical height in divisions by the V/div setting: $$V_{pp} = \text{vertical divisions} \times \text{V/div}$$

<!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; font-family: system-ui, -apple-system, sans-serif; }
    body {
      background: #f8f9fa;
      color: #1e2945;
      padding: 12px;
      display: flex;
      flex-direction: column;
      align-items: center;
      gap: 10px;
      min-height: 100%;
    }

    /* Screen display */
    .scope-container {
      position: relative;
      width: 100%;
      max-width: 440px;
      aspect-ratio: 10 / 8;
      background: #0f172a;
      border-radius: 10px;
      overflow: hidden;
      box-shadow: inset 0 0 12px rgba(0,0,0,0.6);
    }

    svg {
      width: 100%;
      height: 100%;
      display: block;
    }

    /* Controls & readout row */
    .controls-panel {
      width: 100%;
      max-width: 440px;
      display: flex;
      flex-direction: column;
      gap: 8px;
    }

    .btn-row {
      display: flex;
      justify-content: center;
      gap: 6px;
      flex-wrap: wrap;
    }

    .vdiv-btn {
      flex: 1;
      min-width: 70px;
      padding: 8px 4px;
      font-size: 14px;
      font-weight: 600;
      background: #ffffff;
      color: #1e2945;
      border: 1px solid #cbd5e1;
      border-radius: 8px;
      cursor: pointer;
      box-shadow: 0 1px 2px rgba(0,0,0,0.05);
      transition: background 0.2s, color 0.2s, box-shadow 0.2s;
      text-align: center;
    }

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

    .calc-card {
      background: #ffffff;
      border: 1px solid #e2e8f0;
      border-radius: 8px;
      padding: 8px 12px;
      display: flex;
      align-items: center;
      justify-content: space-around;
      font-size: 15px;
      font-weight: 600;
      color: #1e2945;
    }

    .calc-part {
      display: flex;
      align-items: baseline;
      gap: 4px;
    }

    .val-highlight {
      color: #0284c7;
      font-size: 17px;
      font-weight: 700;
    }

    .res-highlight {
      color: #059669;
      font-size: 18px;
      font-weight: 800;
    }
  </style>
</head>
<body>

  
  <div class="scope-container">
    <svg id="scopeSvg" viewBox="0 0 100 80" preserveAspectRatio="none">
      <defs>
        <pattern id="grid" width="10" height="10" patternUnits="userSpaceOnUse">
          <path d="M 10 0 L 0 0 0 10" fill="none" stroke="#1e293b" stroke-width="0.5" />
          <path d="M 5 0 L 5 10 M 0 5 L 10 5" fill="none" stroke="#1e293b" stroke-dasharray="0.6 1.4" stroke-width="0.3" />
        </pattern>
      </defs>

      
      <rect width="100" height="80" fill="#0b1120" />
      <rect width="100" height="80" fill="url(#grid)" />

      
      <line x1="0" y1="40" x2="100" y2="40" stroke="#334155" stroke-width="0.7" />
      <line x1="50" y1="0" x2="50" y2="80" stroke="#334155" stroke-width="0.7" />

      
      <path id="waveform" d="" fill="none" stroke="#38bdf8" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" />

      
      <g id="bracketGroup">
        
        <line id="bTop" x1="68" y1="20" x2="76" y2="20" stroke="#f59e0b" stroke-width="0.9" stroke-linecap="round" />
        
        <line id="bBot" x1="68" y1="60" x2="76" y2="60" stroke="#f59e0b" stroke-width="0.9" stroke-linecap="round" />
        
        <line id="bLine" x1="72" y1="20" x2="72" y2="60" stroke="#f59e0b" stroke-width="1" stroke-dasharray="1 0.8" />
        
        <polygon id="bArrowTop" points="72,20 70,23 74,23" fill="#f59e0b" />
        <polygon id="bArrowBot" points="72,60 70,57 74,57" fill="#f59e0b" />
        
        <text id="svgDivLabel" x="78" y="41" fill="#f59e0b" font-size="4.2" font-weight="bold" alignment-baseline="middle">4 div</text>
      </g>
    </svg>
  </div>

  
  <div class="controls-panel">
    <div class="btn-row">
      <button class="vdiv-btn" data-vdiv="0.5">0.5 V/div</button>
      <button class="vdiv-btn active" data-vdiv="1.0">1.0 V/div</button>
      <button class="vdiv-btn" data-vdiv="2.0">2.0 V/div</button>
      <button class="vdiv-btn" data-vdiv="4.0">4.0 V/div</button>
    </div>

    <div class="calc-card">
      <div class="calc-part">
        <span id="divCount" class="val-highlight">4.0</span> div
      </div>
      <span>×</span>
      <div class="calc-part">
        <span id="vdivVal" class="val-highlight">1.0</span> V/div
      </div>
      <span>=</span>
      <div class="calc-part">
        <span class="res-highlight">V<sub>pp</sub> = 4.0 V</span>
      </div>
    </div>
  </div>

  <script>
    // Constants: Fixed physical signal of Vpp = 4.0 V (Amplitude = 2.0 V)
    const V_PEAK_TO_PEAK = 4.0;
    const GRID_HEIGHT_DIVS = 8;
    const DIV_PX = 10; // SVG coordinate units per grid division

    const wavePath = document.getElementById('waveform');
    const bTop = document.getElementById('bTop');
    const bBot = document.getElementById('bBot');
    const bLine = document.getElementById('bLine');
    const bArrowTop = document.getElementById('bArrowTop');
    const bArrowBot = document.getElementById('bArrowBot');
    const svgDivLabel = document.getElementById('svgDivLabel');
    const divCountEl = document.getElementById('divCount');
    const vdivValEl = document.getElementById('vdivVal');

    function updateScope(vPerDiv) {
      const verticalDivs = V_PEAK_TO_PEAK / vPerDiv;
      const ampUnits = (verticalDivs / 2) * DIV_PX;
      const centerY = 40;

      // Render accurate sine curve
      let d = '';
      const points = 100;
      for (let i = 0; i <= points; i++) {
        const x = i;
        // Two full cycles across 100 units
        const y = centerY - ampUnits * Math.sin((x / 100) * 4 * Math.PI);
        d += (i === 0 ? 'M ' : ' L ') + x.toFixed(1) + ' ' + y.toFixed(1);
      }
      wavePath.setAttribute('d', d);

      // Render bracket positions
      const yTop = centerY - ampUnits;
      const yBot = centerY + ampUnits;

      bTop.setAttribute('y1', yTop);
      bTop.setAttribute('y2', yTop);
      bBot.setAttribute('y1', yBot);
      bBot.setAttribute('y2', yBot);

      bLine.setAttribute('y1', yTop);
      bLine.setAttribute('y2', yBot);

      bArrowTop.setAttribute('points', `72,${yTop} 70.2,${yTop + 2.5} 73.8,${yTop + 2.5}`);
      bArrowBot.setAttribute('points', `72,${yBot} 70.2,${yBot - 2.5} 73.8,${yBot - 2.5}`);

      svgDivLabel.setAttribute('y', centerY + 0.5);
      svgDivLabel.textContent = verticalDivs.toFixed(1) + ' div';

      // Update text outputs
      divCountEl.textContent = verticalDivs.toFixed(1);
      vdivValEl.textContent = vPerDiv.toFixed(1);
    }

    // Interactive button handling
    const buttons = document.querySelectorAll('.vdiv-btn');
    buttons.forEach(btn => {
      btn.addEventListener('click', () => {
        buttons.forEach(b => b.classList.remove('active'));
        btn.classList.add('active');
        const vdiv = parseFloat(btn.getAttribute('data-vdiv'));
        updateScope(vdiv);
      });
    });

    // Initial render
    updateScope(1.0);
  </script>
</body>
</html>

Now that the signal is vertically sized, how do we stretch or compress it horizontally to see individual cycles?

The **timebase** control, labeled **seconds per division (s/div)**, determines how fast the electron beam or digital sampling engine sweeps across the screen from left to right. A smaller time/div value sweeps faster, stretching the waveform out horizontally to reveal fine timing details.

The **period** ($T$) is the time taken to complete one full repeating cycle. You find it by counting horizontal divisions for one complete wave and multiplying by the timebase setting: $$T = \text{horizontal divisions} \times \text{s/div}$$

Because **frequency** ($f$) is the number of complete cycles occurring per second, it is the reciprocal of the period ($f = \frac{1}{T}$).

<!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 {
      background: #0f172a;
      color: #ffffff;
      font-family: system-ui, -apple-system, sans-serif;
      display: flex;
      flex-direction: column;
      align-items: center;
      justify-content: center;
      padding: 12px;
      min-height: 100%;
      user-select: none;
    }
    .scope-frame {
      width: 100%;
      max-width: 580px;
      background: #090d16;
      border: 2px solid #1e293b;
      border-radius: 12px;
      padding: 10px;
      display: flex;
      flex-direction: column;
      gap: 10px;
    }
    .screen-wrapper {
      position: relative;
      width: 100%;
      background: #050b14;
      border-radius: 8px;
      overflow: hidden;
      box-shadow: inset 0 0 20px rgba(0,0,0,0.8);
      border: 1px solid #1e293b;
    }
    svg {
      display: block;
      width: 100%;
      height: auto;
    }
    .controls {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 8px;
    }
    .panel-box {
      background: #131d31;
      border: 1px solid #24324d;
      border-radius: 8px;
      padding: 8px;
      display: flex;
      flex-direction: column;
      gap: 6px;
    }
    .panel-title {
      font-size: 11px;
      font-weight: 700;
      letter-spacing: 0.5px;
      color: #94a3b8;
      text-transform: uppercase;
      display: flex;
      justify-content: space-between;
      align-items: center;
    }
    .btn-group {
      display: flex;
      gap: 4px;
    }
    .btn {
      flex: 1;
      background: #1e293b;
      border: 1px solid #334155;
      color: #e2e8f0;
      padding: 6px 2px;
      font-size: 12px;
      font-weight: 600;
      border-radius: 6px;
      cursor: pointer;
      text-align: center;
      transition: background 0.15s ease, border-color 0.15s ease;
    }
    .btn.active {
      background: #00f2ff;
      color: #050b14;
      border-color: #00f2ff;
      box-shadow: 0 0 10px rgba(0, 242, 255, 0.4);
    }
    .readout-row {
      display: grid;
      grid-template-columns: 1fr 1fr;
      gap: 8px;
      background: #090d16;
      border: 1px solid #1e293b;
      border-radius: 8px;
      padding: 8px 12px;
    }
    .readout {
      font-size: 13px;
      font-weight: 600;
      font-family: ui-monospace, monospace;
      color: #e2e8f0;
    }
    .readout span {
      color: #ff9800;
    }
    .readout-freq {
      color: #00f2ff;
    }
  </style>
</head>
<body>

  <div class="scope-frame">
    <div class="screen-wrapper">
      <svg id="scope" viewBox="0 0 500 320">
        <defs>
          <pattern id="grid" width="50" height="40" patternUnits="userSpaceOnUse">
            <path d="M 50 0 L 0 0 0 40" fill="none" stroke="#16273d" stroke-width="1"/>
            <path d="M 23 20 L 27 20 M 25 18 L 25 22" fill="none" stroke="#16273d" stroke-width="1"/>
          </pattern>
          <marker id="arrow-v" markerWidth="6" markerHeight="6" refX="3" refY="3" orient="auto">
            <path d="M 0 0 L 6 3 L 0 6 z" fill="#ff9800"/>
          </marker>
          <marker id="arrow-h" markerWidth="6" markerHeight="6" refX="3" refY="3" orient="auto">
            <path d="M 0 0 L 6 3 L 0 6 z" fill="#ff9800"/>
          </marker>
        </defs>

        
        <rect width="500" height="320" fill="url(#grid)" />
        
        
        <line x1="250" y1="0" x2="250" y2="320" stroke="#223d61" stroke-width="1.5" stroke-dasharray="3 3"/>
        <line x1="0" y1="160" x2="500" y2="160" stroke="#223d61" stroke-width="1.5" stroke-dasharray="3 3"/>

        
        <path id="trace" fill="none" stroke="#00f2ff" stroke-width="3" stroke-linecap="round" stroke-linejoin="round" />

        
        <g id="cursors">
          
          <line id="v-guide-top" stroke="#ff9800" stroke-width="1" stroke-dasharray="2 2" />
          <line id="v-guide-bot" stroke="#ff9800" stroke-width="1" stroke-dasharray="2 2" />
          <line id="v-arrow" stroke="#ff9800" stroke-width="2" marker-start="url(#arrow-v)" marker-end="url(#arrow-v)" />
          <text id="v-label" fill="#ff9800" font-size="12" font-weight="700" font-family="system-ui" text-anchor="middle"></text>

          
          <line id="t-guide-left" stroke="#ff9800" stroke-width="1" stroke-dasharray="2 2" />
          <line id="t-guide-right" stroke="#ff9800" stroke-width="1" stroke-dasharray="2 2" />
          <line id="t-arrow" stroke="#ff9800" stroke-width="2" marker-start="url(#arrow-h)" marker-end="url(#arrow-h)" />
          <text id="t-label" fill="#ff9800" font-size="12" font-weight="700" font-family="system-ui" text-anchor="middle"></text>
        </g>
      </svg>
    </div>

    
    <div class="controls">
      <div class="panel-box">
        <div class="panel-title">Volts / Div <span id="v-val">1 V</span></div>
        <div class="btn-group">
          <button class="btn" onclick="setV(0.5)">0.5 V</button>
          <button class="btn active" onclick="setV(1)">1.0 V</button>
          <button class="btn" onclick="setV(2)">2.0 V</button>
        </div>
      </div>
      <div class="panel-box">
        <div class="panel-title">Timebase <span id="t-val">1 ms</span></div>
        <div class="btn-group">
          <button class="btn" onclick="setT(0.5)">0.5 ms</button>
          <button class="btn active" onclick="setT(1)">1.0 ms</button>
          <button class="btn" onclick="setT(2)">2.0 ms</button>
        </div>
      </div>
    </div>

    
    <div class="readout-row">
      <div class="readout" id="readout-v">V<sub>pp</sub>: <span>4.0 div × 1 V = 4.0 V</span></div>
      <div class="readout" id="readout-t">T: <span>4.0 div × 1 ms = 4.0 ms</span><br><span class="readout-freq">f = 1/T = 250 Hz</span></div>
    </div>
  </div>

  <script>
    // Fixed input test signal: Vpp = 4V (amplitude 2V), Period T = 4ms (f = 250 Hz)
    const SIGNAL_VPP = 4.0;
    const SIGNAL_T = 4.0;

    let vPerDiv = 1.0;
    let tPerDiv = 1.0;

    const W = 500;
    const H = 320;
    const DIV_X = 50; // px per div (10 divs wide)
    const DIV_Y = 40; // px per div (8 divs high)
    const CY = H / 2;

    function render() {
      // Calculate divisions
      const vDivs = SIGNAL_VPP / vPerDiv;
      const tDivs = SIGNAL_T / tPerDiv;

      // Amplitude in pixels
      const ampPx = (vDivs / 2) * DIV_Y;
      // Wavelength in pixels
      const lambdaPx = tDivs * DIV_X;

      // Build accurate Sine Wave SVG Path
      let d = "";
      const step = 2;
      for (let x = 0; x <= W; x += step) {
        const angle = ((x - 250) / lambdaPx) * 2 * Math.PI;
        const y = CY - ampPx * Math.sin(angle);
        d += (x === 0 ? "M " : " L ") + x.toFixed(1) + " " + y.toFixed(1);
      }
      document.getElementById('trace').setAttribute('d', d);

      // Vertical cursors (Vpp)
      const topY = CY - ampPx;
      const botY = CY + ampPx;
      const curX = 140;

      const vTop = document.getElementById('v-guide-top');
      vTop.setAttribute('x1', curX - 25);
      vTop.setAttribute('y1', topY);
      vTop.setAttribute('x2', curX + 25);
      vTop.setAttribute('y2', topY);

      const vBot = document.getElementById('v-guide-bot');
      vBot.setAttribute('x1', curX - 25);
      vBot.setAttribute('y1', botY);
      vBot.setAttribute('x2', curX + 25);
      vBot.setAttribute('y2', botY);

      const vArrow = document.getElementById('v-arrow');
      vArrow.setAttribute('x1', curX);
      vArrow.setAttribute('y1', topY + 4);
      vArrow.setAttribute('x2', curX);
      vArrow.setAttribute('y2', botY - 4);

      const vLabel = document.getElementById('v-label');
      vLabel.setAttribute('x', curX - 12);
      vLabel.setAttribute('y', CY + 4);
      vLabel.textContent = `${vDivs.toFixed(1)} div`;

      // Horizontal cursors (Period T)
      // Cycle from peak to peak around center: peak1 = 250 - lambdaPx * 0.75, peak2 = 250 + lambdaPx * 0.25
      // Or simply 0 to lambdaPx from first positive zero crossing
      let startX = 250;
      while (startX > lambdaPx) startX -= lambdaPx;
      const endX = startX + lambdaPx;
      const curY = 270;

      const tLeft = document.getElementById('t-guide-left');
      tLeft.setAttribute('x1', startX);
      tLeft.setAttribute('y1', CY);
      tLeft.setAttribute('x2', startX);
      tLeft.setAttribute('y2', curY + 15);

      const tRight = document.getElementById('t-guide-right');
      tRight.setAttribute('x1', endX);
      tRight.setAttribute('y1', CY);
      tRight.setAttribute('x2', endX);
      tRight.setAttribute('y2', curY + 15);

      const tArrow = document.getElementById('t-arrow');
      tArrow.setAttribute('x1', startX + 4);
      tArrow.setAttribute('y1', curY);
      tArrow.setAttribute('x2', endX - 4);
      tArrow.setAttribute('y2', curY);

      const tLabel = document.getElementById('t-label');
      tLabel.setAttribute('x', (startX + endX) / 2);
      tLabel.setAttribute('y', curY - 6);
      tLabel.textContent = `T = ${tDivs.toFixed(1)} div`;

      // Update Math Readouts
      document.getElementById('readout-v').innerHTML = 
        `V<sub>pp</sub>: <span>${vDivs.toFixed(1)} div × ${vPerDiv}V = ${SIGNAL_VPP.toFixed(1)} V</span>`;
      
      const fHz = Math.round(1000 / SIGNAL_T);
      document.getElementById('readout-t').innerHTML = 
        `T: <span>${tDivs.toFixed(1)} div × ${tPerDiv}ms = ${SIGNAL_T.toFixed(1)} ms</span><br><span class="readout-freq">f = 1/T = ${fHz} Hz</span>`;
    }

    function setV(val) {
      vPerDiv = val;
      document.getElementById('v-val').textContent = val + ' V';
      document.querySelectorAll('.controls .panel-box:first-child .btn').forEach(b => {
        b.classList.toggle('active', parseFloat(b.textContent) === val);
      });
      render();
    }

    function setT(val) {
      tPerDiv = val;
      document.getElementById('t-val').textContent = val + ' ms';
      document.querySelectorAll('.controls .panel-box:last-child .btn').forEach(b => {
        b.classList.toggle('active', parseFloat(b.textContent) === val);
      });
      render();
    }

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

What does a complete end-to-end signal measurement look like in practice?

Suppose you connect a probe to an unknown oscillator output. You set the vertical sensitivity to $0.5\text{ V/div}$ and the timebase to $50\,\mu\text{s/div}$, producing a clean wave that spans $6.4$ vertical divisions peak-to-peak and $4.0$ horizontal divisions per cycle.

First, calculate the amplitude and peak-to-peak voltage: $$V_{pp} = 6.4\text{ div} \times 0.5\text{ V/div} = 3.2\text{ V}$$ The peak voltage ($V_p$) relative to the center baseline is half of $V_{pp}$, giving $1.6\text{ V}$.

Next, calculate the period and frequency: $$T = 4.0\text{ div} \times 50\times 10^{-6}\text{ s/div} = 200\,\mu\text{s} = 0.0002\text{ s}$$ $$f = \frac{1}{200\times 10^{-6}\text{ s}} = 5000\text{ Hz} = 5\text{ kHz}$$

Why do laboratory measurements sometimes read exactly one-tenth of the expected voltage?

Most passive oscilloscope probes have a physical slide switch toggle between **1x** and **10x** attenuation. In 10x mode, a built-in resistor reduces the incoming voltage signal by a factor of 10 to protect the scope and avoid loading the circuit under test.

If your probe hardware is set to $10\times$ but your digital scope channel menu is set to $1\times$, all measured voltages will read ten times too small. Always ensure the attenuation factor on your physical probe matches the multiplier setting on your oscilloscope screen.

Whenever you approach an unfamiliar waveform in the lab, adjust your V/div until the signal fills roughly 60% to 80% of the vertical screen height, then tune your timebase until you can clearly see 2 to 3 full cycles.

electronics

Oscilloscope Controls: Volts per Division and Timebase. Configure vertical sensitivity (V/div) and horizontal sweep (s/div) to scale and display signals clearly.

A-Level Physics: Using an Oscilloscope & Measuring AC Signals

Isaac Physics Skills: Cathode-Ray Oscilloscope and Wave Measurements

Virtual Oscilloscope Interactive Graticule Simulator

Pedagogical strategy focuses on treating the oscilloscope screen as a calibrated two-dimensional coordinate system ($y = \text{voltage}$, $x = \text{time}$). Teaching must emphasize experimental uncertainty reduction: students should always re-scale sensitivity and sweep to maximize screen real estate before taking readings. Practical laboratory integration with dual-channel signal generators reinforces the distinction between manipulating signal source properties versus adjusting measurement display parameters.

Oscilloscope Controls: Volts per Division and Timebase

Vertical Sensitivity: Volts per Division

Horizontal Sweep: The Timebase