72  ADC Resolution Visualizer

Understanding Analog-to-Digital Conversion

72.1 ADC Resolution Visualizer

NoteLearning Objectives

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

• Understand how bits translate to measurement steps
• Visualize quantization error in real-time
• Calculate voltage resolution for different ADC configurations
• Apply ADC concepts to real sensor applications

TipFor Beginners: What is an ADC?

ADC = Analog-to-Digital Converter - It turns smooth analog voltages into discrete digital numbers.

Concept	Explanation
Resolution	Number of bits - determines how many “steps”
8-bit ADC	256 steps (2^8)
10-bit ADC	1024 steps (2^10)
12-bit ADC	4096 steps (2^12)

Real Example: A 10-bit ADC measuring 0-3.3V:

• Step size = 3.3V / 1024 = 3.2 mV per step
• Temperature sensor with 10mV/C resolution needs 3+ ADC steps per degree

---

72.2 Quick Start Presets

NoteCommon Microcontroller ADC Configurations

Platform	ADC Resolution	Reference Voltage	Typical Use
Arduino Uno	10-bit	5.0V	Hobby projects, basic sensors
Arduino Due	12-bit	3.3V	Higher precision applications
ESP32	12-bit	3.3V	Wi-Fi IoT devices
STM32F4	12-bit	3.3V	Industrial applications
Raspberry Pi Pico	12-bit	3.3V	Education, prototyping
nRF52840	14-bit	0.6-3.6V	Low-power BLE devices
ADS1115 (external)	16-bit	2.048-6.144V	High-precision measurement

Choosing ADC Resolution:

• 8-bit: Basic on/off detection, coarse measurements
• 10-bit: General sensing, temperature, light levels
• 12-bit: Most IoT applications, good balance of precision/speed
• 14-16 bit: Scientific instruments, audio, precision measurement

---

72.3 ADC Configuration

viewof adcBits = Inputs.range([4, 16], {
  label: "ADC Resolution (bits):",
  step: 1,
  value: 10
})

viewof referenceVoltage = Inputs.range([1.0, 5.0], {
  label: "Reference Voltage (V):",
  step: 0.1,
  value: 3.3
})

viewof inputSignalType = Inputs.radio(
  ["Sine Wave", "Triangle", "DC Level", "Sensor Simulation"],
  {label: "Input Signal:", value: "Sine Wave"}
)

viewof inputAmplitude = Inputs.range([0.1, 1.0], {
  label: "Signal Amplitude (fraction of Vref):",
  step: 0.05,
  value: 0.8
})

---

72.4 ADC Statistics

adcStats = {
  const levels = Math.pow(2, adcBits);
  const stepSize = referenceVoltage / levels;
  const maxQuantError = stepSize / 2;
  const snrDb = 6.02 * adcBits + 1.76;
  const enob = (snrDb - 1.76) / 6.02;

  return {
    bits: adcBits,
    levels: levels,
    stepSize: stepSize,
    stepSizeMv: stepSize * 1000,
    maxQuantError: maxQuantError,
    maxQuantErrorMv: maxQuantError * 1000,
    snrDb: snrDb,
    enob: enob,
    vref: referenceVoltage
  };
}

html`
<div style="background: linear-gradient(135deg, #E8F6F3 0%, #D5F4E6 100%);
            padding: 25px; border-radius: 12px; margin: 20px 0;">
  <h3 style="margin-top: 0; color: #16A085;">ADC Specifications</h3>

  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(180px, 1fr)); gap: 15px;">
    <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
      <div style="color: #666; font-size: 11px;">RESOLUTION</div>
      <div style="font-size: 28px; font-weight: bold; color: #2C3E50;">
        ${adcStats.bits}-bit
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
      <div style="color: #666; font-size: 11px;">QUANTIZATION LEVELS</div>
      <div style="font-size: 28px; font-weight: bold; color: #E67E22;">
        ${adcStats.levels.toLocaleString()}
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
      <div style="color: #666; font-size: 11px;">STEP SIZE (LSB)</div>
      <div style="font-size: 28px; font-weight: bold; color: #27AE60;">
        ${adcStats.stepSizeMv < 1 ? adcStats.stepSizeMv.toFixed(3) : adcStats.stepSizeMv.toFixed(2)} mV
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
      <div style="color: #666; font-size: 11px;">MAX QUANT. ERROR</div>
      <div style="font-size: 28px; font-weight: bold; color: #E74C3C;">
        +/-${adcStats.maxQuantErrorMv < 1 ? adcStats.maxQuantErrorMv.toFixed(3) : adcStats.maxQuantErrorMv.toFixed(2)} mV
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
      <div style="color: #666; font-size: 11px;">THEORETICAL SNR</div>
      <div style="font-size: 28px; font-weight: bold; color: #3498DB;">
        ${adcStats.snrDb.toFixed(1)} dB
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 10px; text-align: center;">
      <div style="color: #666; font-size: 11px;">REFERENCE VOLTAGE</div>
      <div style="font-size: 28px; font-weight: bold; color: #9B59B6;">
        ${adcStats.vref.toFixed(1)} V
      </div>
    </div>
  </div>
</div>
`

---

72.5 Signal Visualization

d3 = require("d3@7")

// Generate analog signal
analogSignal = {
  const points = [];
  const numPoints = 200;
  const vref = referenceVoltage;
  const amp = inputAmplitude * vref / 2;
  const offset = vref / 2;

  for (let i = 0; i < numPoints; i++) {
    const t = i / numPoints;
    let value;

    if (inputSignalType === "Sine Wave") {
      value = offset + amp * Math.sin(2 * Math.PI * 2 * t);
    } else if (inputSignalType === "Triangle") {
      const phase = (t * 2) % 1;
      value = offset + amp * (phase < 0.5 ? 4 * phase - 1 : 3 - 4 * phase);
    } else if (inputSignalType === "DC Level") {
      value = offset + amp * 0.5;
    } else {
      const noise = (Math.random() - 0.5) * 0.1 * amp;
      const trend = amp * 0.3 * Math.sin(2 * Math.PI * 0.5 * t);
      value = offset + trend + noise;
    }

    value = Math.max(0, Math.min(vref, value));
    points.push({t: t, analog: value});
  }

  return points;
}

// Quantize the signal
quantizedSignal = {
  const levels = Math.pow(2, adcBits);
  const stepSize = referenceVoltage / levels;

  return analogSignal.map(p => {
    const digitalCode = Math.floor(p.analog / stepSize);
    const clampedCode = Math.min(levels - 1, Math.max(0, digitalCode));
    const quantized = (clampedCode + 0.5) * stepSize;
    const error = p.analog - quantized;

    return {
      t: p.t,
      analog: p.analog,
      digitalCode: clampedCode,
      quantized: quantized,
      error: error
    };
  });
}

// Create the visualization
{
  const width = 700;
  const height = 400;
  const margin = {top: 30, right: 60, bottom: 40, left: 60};
  const innerWidth = width - margin.left - margin.right;
  const innerHeight = height - margin.top - margin.bottom;

  const svg = d3.create("svg")
    .attr("viewBox", [0, 0, width, height])
    .attr("style", "max-width: 100%; height: auto;");

  const xScale = d3.scaleLinear()
    .domain([0, 1])
    .range([margin.left, width - margin.right]);

  const yScale = d3.scaleLinear()
    .domain([0, referenceVoltage])
    .range([height - margin.bottom, margin.top]);

  // Draw quantization levels (horizontal lines)
  const levels = Math.pow(2, adcBits);
  const stepSize = referenceVoltage / levels;
  const visibleLevels = Math.min(levels, 32);
  const levelStep = Math.max(1, Math.floor(levels / visibleLevels));

  for (let i = 0; i <= levels; i += levelStep) {
    const y = yScale(i * stepSize);
    svg.append("line")
      .attr("x1", margin.left)
      .attr("x2", width - margin.right)
      .attr("y1", y)
      .attr("y2", y)
      .attr("stroke", "#E5E5E5")
      .attr("stroke-width", 0.5);
  }

  // Analog signal line
  const analogLine = d3.line()
    .x(d => xScale(d.t))
    .y(d => yScale(d.analog));

  svg.append("path")
    .datum(analogSignal)
    .attr("fill", "none")
    .attr("stroke", "#3498DB")
    .attr("stroke-width", 2)
    .attr("d", analogLine);

  // Quantized signal (staircase)
  const quantizedLine = d3.line()
    .x(d => xScale(d.t))
    .y(d => yScale(d.quantized))
    .curve(d3.curveStepAfter);

  svg.append("path")
    .datum(quantizedSignal)
    .attr("fill", "none")
    .attr("stroke", "#E74C3C")
    .attr("stroke-width", 2)
    .attr("d", quantizedLine);

  // X axis
  svg.append("g")
    .attr("transform", `translate(0,${height - margin.bottom})`)
    .call(d3.axisBottom(xScale).ticks(5).tickFormat(d => `${(d * 100).toFixed(0)}%`))
    .call(g => g.append("text")
      .attr("x", width / 2)
      .attr("y", 35)
      .attr("fill", "#666")
      .attr("text-anchor", "middle")
      .text("Time"));

  // Y axis
  svg.append("g")
    .attr("transform", `translate(${margin.left},0)`)
    .call(d3.axisLeft(yScale).ticks(8).tickFormat(d => `${d.toFixed(2)}V`))
    .call(g => g.append("text")
      .attr("transform", "rotate(-90)")
      .attr("x", -height / 2)
      .attr("y", -45)
      .attr("fill", "#666")
      .attr("text-anchor", "middle")
      .text("Voltage"));

  // Legend
  const legend = svg.append("g")
    .attr("transform", `translate(${width - margin.right - 120}, ${margin.top})`);

  legend.append("rect")
    .attr("width", 115)
    .attr("height", 60)
    .attr("fill", "white")
    .attr("stroke", "#ddd")
    .attr("rx", 5);

  legend.append("line")
    .attr("x1", 10).attr("x2", 30)
    .attr("y1", 20).attr("y2", 20)
    .attr("stroke", "#3498DB").attr("stroke-width", 2);

  legend.append("text")
    .attr("x", 35).attr("y", 24)
    .attr("font-size", "12px")
    .text("Analog");

  legend.append("line")
    .attr("x1", 10).attr("x2", 30)
    .attr("y1", 40).attr("y2", 40)
    .attr("stroke", "#E74C3C").attr("stroke-width", 2);

  legend.append("text")
    .attr("x", 35).attr("y", 44)
    .attr("font-size", "12px")
    .text("Quantized");

  return svg.node();
}

---

72.6 Quantization Error Analysis

errorStats = {
  const errors = quantizedSignal.map(d => d.error);
  const absErrors = errors.map(e => Math.abs(e));
  const maxError = Math.max(...absErrors);
  const avgError = absErrors.reduce((a, b) => a + b, 0) / absErrors.length;
  const rmsError = Math.sqrt(errors.reduce((a, e) => a + e * e, 0) / errors.length);

  return {
    maxError: maxError,
    maxErrorMv: maxError * 1000,
    avgError: avgError,
    avgErrorMv: avgError * 1000,
    rmsError: rmsError,
    rmsErrorMv: rmsError * 1000,
    theoretical: adcStats.maxQuantError,
    theoreticalMv: adcStats.maxQuantErrorMv
  };
}

html`
<div style="background: #f8f9fa; padding: 20px; border-radius: 12px; margin: 20px 0;">
  <h4 style="margin-top: 0;">Quantization Error Statistics</h4>

  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px;">
    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">Maximum Error (measured)</div>
      <div style="font-size: 24px; font-weight: bold; color: #E74C3C;">
        ${errorStats.maxErrorMv.toFixed(3)} mV
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">Average Error</div>
      <div style="font-size: 24px; font-weight: bold; color: #E67E22;">
        ${errorStats.avgErrorMv.toFixed(3)} mV
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">RMS Error</div>
      <div style="font-size: 24px; font-weight: bold; color: #9B59B6;">
        ${errorStats.rmsErrorMv.toFixed(3)} mV
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">Theoretical Max (LSB/2)</div>
      <div style="font-size: 24px; font-weight: bold; color: #27AE60;">
        ${errorStats.theoreticalMv.toFixed(3)} mV
      </div>
    </div>
  </div>
</div>
`

---

72.7 IoT Sensor Applications

How does ADC resolution affect real sensor measurements?

sensorExamples = [
  {
    name: "Temperature (LM35)",
    sensitivity: 10,
    unit: "mV/C",
    range: "0-100C",
    minBits: 8,
    recommendedBits: 10,
    explanation: "10mV/C output needs ~3 ADC steps per degree for 0.3C resolution"
  },
  {
    name: "Light (LDR)",
    sensitivity: 0,
    unit: "variable",
    range: "0-Vref",
    minBits: 8,
    recommendedBits: 10,
    explanation: "Non-linear response, 10-bit gives good dynamic range"
  },
  {
    name: "Pressure (MPX5700)",
    sensitivity: 6.4,
    unit: "mV/kPa",
    range: "15-700 kPa",
    minBits: 10,
    recommendedBits: 12,
    explanation: "6.4mV/kPa needs 12-bit for 0.5 kPa resolution"
  },
  {
    name: "Current (ACS712)",
    sensitivity: 185,
    unit: "mV/A",
    range: "0-5A",
    minBits: 10,
    recommendedBits: 12,
    explanation: "185mV/A is good, but noise requires oversampling"
  },
  {
    name: "Accelerometer (ADXL345)",
    sensitivity: 0,
    unit: "digital",
    range: "+/-16g",
    minBits: 10,
    recommendedBits: 13,
    explanation: "Internal 13-bit ADC, SPI/I2C output (no external ADC needed)"
  },
  {
    name: "pH Sensor",
    sensitivity: 59.16,
    unit: "mV/pH",
    range: "0-14 pH",
    minBits: 10,
    recommendedBits: 12,
    explanation: "59.16mV per pH unit at 25C, 12-bit for 0.01 pH resolution"
  }
]

viewof selectedSensor = Inputs.select(sensorExamples, {
  label: "Select Sensor Type:",
  format: s => s.name
})

sensorAnalysis = {
  const stepMv = adcStats.stepSizeMv;
  const sensor = selectedSensor;

  let stepsPerUnit = 0;
  let resolution = 0;
  let adequate = false;

  if (sensor.sensitivity > 0) {
    stepsPerUnit = sensor.sensitivity / stepMv;
    resolution = stepMv / sensor.sensitivity;
    adequate = stepsPerUnit >= 2;
  } else {
    stepsPerUnit = adcStats.levels;
    resolution = 100 / adcStats.levels;
    adequate = adcStats.bits >= sensor.minBits;
  }

  return {
    stepsPerUnit: stepsPerUnit,
    resolution: resolution,
    adequate: adequate,
    meetsMin: adcStats.bits >= sensor.minBits,
    meetsRecommended: adcStats.bits >= sensor.recommendedBits
  };
}

html`
<div style="background: ${sensorAnalysis.meetsRecommended ? '#D5F4E6' : sensorAnalysis.meetsMin ? '#FEF5E7' : '#FADBD8'};
            padding: 20px; border-radius: 12px; margin: 20px 0;">
  <h4 style="margin-top: 0; color: #2C3E50;">${selectedSensor.name} Analysis</h4>

  <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(200px, 1fr)); gap: 15px; margin-bottom: 15px;">
    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">Sensor Sensitivity</div>
      <div style="font-size: 20px; font-weight: bold;">
        ${selectedSensor.sensitivity > 0 ? selectedSensor.sensitivity + ' ' + selectedSensor.unit : 'Digital output'}
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">Measurement Range</div>
      <div style="font-size: 20px; font-weight: bold;">
        ${selectedSensor.range}
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">Minimum ADC</div>
      <div style="font-size: 20px; font-weight: bold; color: ${sensorAnalysis.meetsMin ? '#27AE60' : '#E74C3C'};">
        ${selectedSensor.minBits}-bit ${sensorAnalysis.meetsMin ? '(OK)' : '(Need more!)'}
      </div>
    </div>

    <div style="background: white; padding: 15px; border-radius: 8px;">
      <div style="color: #666; font-size: 12px;">Recommended ADC</div>
      <div style="font-size: 20px; font-weight: bold; color: ${sensorAnalysis.meetsRecommended ? '#27AE60' : '#E67E22'};">
        ${selectedSensor.recommendedBits}-bit ${sensorAnalysis.meetsRecommended ? '(Excellent)' : '(Consider upgrading)'}
      </div>
    </div>
  </div>

  <div style="background: white; padding: 15px; border-radius: 8px;">
    <strong>Analysis:</strong> ${selectedSensor.explanation}
    <br><br>
    <strong>With your ${adcStats.bits}-bit ADC:</strong>
    ${selectedSensor.sensitivity > 0 ?
      `You get ${sensorAnalysis.stepsPerUnit.toFixed(1)} ADC steps per measurement unit, giving ${sensorAnalysis.resolution.toFixed(3)} unit resolution.` :
      `Digital sensor - ADC resolution affects other analog measurements in your system.`
    }
  </div>
</div>
`

---

72.8 Resolution Comparison Table

resolutionTable = {
  const configs = [8, 10, 12, 14, 16];
  const vref = referenceVoltage;

  return configs.map(bits => {
    const levels = Math.pow(2, bits);
    const stepMv = (vref / levels) * 1000;
    const snr = 6.02 * bits + 1.76;

    return {
      bits: bits,
      levels: levels,
      stepMv: stepMv,
      snr: snr,
      tempRes: stepMv / 10,
      current: bits === adcBits
    };
  });
}

html`
<div style="overflow-x: auto; margin: 20px 0;">
  <table style="width: 100%; border-collapse: collapse; min-width: 600px;">
    <thead>
      <tr style="background: #2C3E50; color: white;">
        <th style="padding: 12px; text-align: left;">Resolution</th>
        <th style="padding: 12px; text-align: right;">Levels</th>
        <th style="padding: 12px; text-align: right;">Step Size</th>
        <th style="padding: 12px; text-align: right;">SNR</th>
        <th style="padding: 12px; text-align: right;">Temp Resolution*</th>
        <th style="padding: 12px; text-align: center;">Common Use</th>
      </tr>
    </thead>
    <tbody>
      ${resolutionTable.map(r => html`
        <tr style="background: ${r.current ? '#D5F4E6' : 'white'}; border-bottom: 1px solid #ddd;">
          <td style="padding: 12px; font-weight: ${r.current ? 'bold' : 'normal'};">
            ${r.bits}-bit ${r.current ? '(selected)' : ''}
          </td>
          <td style="padding: 12px; text-align: right; font-family: monospace;">
            ${r.levels.toLocaleString()}
          </td>
          <td style="padding: 12px; text-align: right; font-family: monospace;">
            ${r.stepMv < 1 ? r.stepMv.toFixed(3) : r.stepMv.toFixed(2)} mV
          </td>
          <td style="padding: 12px; text-align: right;">
            ${r.snr.toFixed(1)} dB
          </td>
          <td style="padding: 12px; text-align: right;">
            ${r.tempRes < 1 ? r.tempRes.toFixed(2) : r.tempRes.toFixed(1)} C
          </td>
          <td style="padding: 12px; text-align: center; font-size: 12px;">
            ${r.bits <= 8 ? 'Basic sensors' :
              r.bits <= 10 ? 'General IoT' :
              r.bits <= 12 ? 'Precision sensors' :
              r.bits <= 14 ? 'Scientific' : 'High-precision'}
          </td>
        </tr>
      `)}
    </tbody>
  </table>
  <div style="font-size: 12px; color: #666; margin-top: 10px;">
    * Assuming LM35-type sensor with 10mV/C sensitivity at ${referenceVoltage}V reference
  </div>
</div>
`

---

72.9 Knowledge Check

NoteQuestion 1

A 12-bit ADC with 3.3V reference has a step size of:

1. 0.8 mV
2. 3.2 mV
3. 12.9 mV
4. 0.3 mV

TipAnswer

A) 0.8 mV - Step size = Vref / 2^bits = 3.3V / 4096 = 0.000806V = 0.8 mV. Each digital code represents an 0.8mV change in input voltage.

NoteQuestion 2

Why might a 16-bit ADC not provide 16 bits of useful data?

1. The math is wrong
2. Noise, non-linearity, and other errors limit effective resolution
3. 16-bit ADCs are fake
4. The sensor determines ADC bits

TipAnswer

B) Noise, non-linearity, and other errors limit effective resolution - Real ADCs have noise, offset drift, and non-linearity that reduce the Effective Number of Bits (ENOB). A 16-bit ADC might only provide 12-14 ENOB in practice.

NoteQuestion 3

You need to measure temperature with 0.1C resolution using an LM35 (10mV/C). What minimum ADC resolution is needed with 3.3V reference?

1. 8-bit
2. 10-bit
3. 12-bit
4. 14-bit

TipAnswer

C) 12-bit - For 0.1C resolution, you need to detect 1mV changes (10mV/C x 0.1C). With 3.3V reference: 8-bit gives 12.9mV, 10-bit gives 3.2mV, 12-bit gives 0.8mV. You need at least 12-bit to resolve 1mV changes reliably.

---

72.10 Quick Reference

Resolution	Levels	3.3V Step	5V Step	SNR
8-bit	256	12.9 mV	19.5 mV	50 dB
10-bit	1,024	3.2 mV	4.9 mV	62 dB
12-bit	4,096	0.8 mV	1.2 mV	74 dB
14-bit	16,384	0.2 mV	0.3 mV	86 dB
16-bit	65,536	0.05 mV	0.08 mV	98 dB

Common Microcontroller ADCs:

• Arduino Uno: 10-bit (1024 levels)
• ESP32: 12-bit (4096 levels)
• STM32: 12-bit typical (some have 16-bit)
• Raspberry Pi Pico: 12-bit (via RP2040)

---

72.11 Related Resources

• Sampling Visualizer - Nyquist and aliasing
• Binary & Hex Converter - Understanding digital values
• Sensor Calibration Tool - Calibrating sensor readings
• Data Representation - Digital data fundamentals