Capture two references and validate a calibration

Fit gain and offset from two potentiometer references, then check a fresh midpoint and reset the correction.

How to complete this Wokwi lab

Your task: Capture two references and validate a calibration

Goal: Fit gain and offset from two potentiometer references, then check a fresh midpoint and reset the correction.

Open the simulator · Read the full text instructions

Use this checklist as you work. Checks last only on this page and do not submit or record completion.

Step 1: In Wokwi's project editor, paste diagram.json and sketch.ino into a new Wokwi ESP32 project; inspect the potentiometer and status LED connections. Details for step 1
Step 2: In the Simulation toolbar, start the run; read steady midpoint values in Serial Monitor. Details for step 2
Step 3: In the Serial Monitor input field, send c to start the calibration procedure. Details for step 3
Step 4: In the potentiometer control panel, set 153 of 1023; then send l in Serial Monitor. Details for step 4
Step 5: In the potentiometer control panel, set 870 of 1023; then send h in Serial Monitor. Details for step 5
Step 6: In the potentiometer control panel, restore 512 and read settled Serial Monitor rows. Details for step 6
Step 7: In the Serial Monitor input field, send r and read the next steady row. Details for step 7

Simulator unavailable? Use the text fallback

Follow the checklist using the recorded results below. Predict each change, compare it with the recorded result, and explain why it matters. These are the lab's recorded results, not measurements you have made. Run the simulator later to test your predictions.

Recorded result for step 1

LED anode connects to ESP32 GPIO2 (diagram.json line 55). LED cathode returns through ledR to ESP32 ground (diagram.json lines 61, 67). The LED’s series resistor ledR is 220 Ω (diagram.json line 24). Power: potentiometer VCC connects to ESP32 3.3 V; GND returns to ground (diagram.json lines 73, 79). Potentiometer signal connects to ESP32 GPIO34 (diagram.json line 85).

Why it matters: GPIO34 supplies the raw ADC endpoints used later for calibration. The status LED on GPIO2 reports the procedure state through a current-limited path.
Recorded result for step 2

Input: supplied potentiometer midpoint. Observed: "RAW: 50.1% | FILTERED: 50.1% | CALIBRATED: 50.1% | CORRECTION: 0.00%". Observed: the same row repeats before calibration. Expected: uncalibrated midpoint has zero correction.

Why it matters: The raw and filtered readings agree at 50.1%. The calibrated value begins at the same value. The correction is zero before reference capture. This is the baseline for the next two points.
Recorded result for step 3

Input: send c. Observed: "CALIBRATION PROCEDURE STARTED". Observed: "Step 1: Set the potentiometer to the LOW reference point". Observed: "(This represents 10% actual value)".

Why it matters: The sketch enters its calibration procedure. It requests the low reference first. The declared actual value is 10%. A reference must be captured before the gain is computed.
Recorded result for step 4

Input: potentiometer control 153, then command l. Observed: "LOW POINT CAPTURED: Raw = 14.9% (Actual = 10%)". Observed: the monitor next requests the HIGH reference. Expected: store 14.9% raw as the 10% actual reference.

Why it matters: The sensor model reads above the declared actual low point. The command records both raw and actual values. The later high point is still needed for a two-point fit. The 14.9% value matches the real screenshot.
Recorded result for step 5

Input: potentiometer control 870, then command h. Observed: "HIGH POINT CAPTURED: Raw = 85.1% (Actual = 90%)". Observed: "Low point: Raw=14.9% -> Calibrated=10.0% (Expected: 10.0%)". Observed: "High point: Raw=85.1% -> Calibrated=90.0% (Expected: 90.0%)".

Why it matters: The high raw value falls below its declared actual reference. The two captured pairs define a linear correction. Verification maps the low reference to 10.0%. Verification maps the high reference to 90.0%.
Recorded result for step 6

Input: potentiometer control restored to 512. Observed: "RAW: 50.1% | FILTERED: 50.1% | CALIBRATED: 50.1% | CORRECTION: 0.01%". Observed: the settled row repeats. Expected: midpoint returns with a small correction.

Why it matters: The raw and filtered readings settle together. The calibrated reading is 50.1%. The residual correction is 0.01%. This midpoint checks interpolation between references.
Recorded result for step 7

Input: send r after midpoint has settled. Observed: "Calibration RESET to defaults (gain=1.0, offset=0.0)". Observed: "RAW: 50.1% | FILTERED: 50.1% | CALIBRATED: 50.1% | CORRECTION: 0.00%". Expected: default gain and offset remove the correction.

Why it matters: The gain returns to one. The offset returns to zero. The displayed correction returns to 0.00%. The midpoint remains the same controlled input.

Review the detailed text steps and cautions below.

Physics Phoebe: I want you to fit the two references, then test a reading you did not use for the fit., your practice guide

Physics Phoebe: I want you to fit the two references, then test a reading you did not use for the fit.
Predict the reading, then compare it with the measurement.

Wokwi ESP32

Third party Tool

Tier 1 · Web · No account

Version tested: Compiled and booted by the Wokwi gate (ESP32 Arduino core 3.3.11); captured in the Wokwi web editor on 2026-09-09. Date: 2026-09-09.

Open the ESP32 editor, paste diagram.json, then paste sketch.ino.

Open Wokwi to paste in the files (new tab)

Get the files

Use both prepared files. This is a paste-in setup; saving a project requires a Wokwi account.

diagram.json

1,245 bytes · Circuit connections

Download

{
  "version": 1,
  "author": "IoTClass",
  "editor": "wokwi",
  "parts": [
    {
      "type": "wokwi-esp32-devkit-v1",
      "id": "esp",
      "top": 100,
      "left": 50,
      "attrs": {}
    },
    {
      "type": "wokwi-led",
      "id": "led",
      "top": -70,
      "left": 250,
      "attrs": {
        "color": "red"
      }
    },
    {
      "type": "wokwi-resistor",
      "id": "ledR",
      "top": -5,
      "left": 250,
      "attrs": {
        "value": "220"
      }
    },
    {
      "type": "wokwi-potentiometer",
      "id": "pot",
      "top": -90,
      "left": 0,
      "attrs": {
        "value": "512"
      }
    }
  ],
  "connections": [
    [
      "esp:TX0",
      "$serialMonitor:RX",
      "",
      []
    ],
    [
      "esp:RX0",
      "$serialMonitor:TX",
      "",
      []
    ],
    [
      "esp:D2",
      "led:A",
      "red",
      []
    ],
    [
      "led:C",
      "ledR:1",
      "black",
      []
    ],
    [
      "ledR:2",
      "esp:GND.1",
      "black",
      []
    ],
    [
      "pot:VCC",
      "esp:3V3",
      "red",
      []
    ],
    [
      "pot:GND",
      "esp:GND.1",
      "black",
      []
    ],
    [
      "pot:SIG",
      "esp:D34",
      "green",
      []
    ]
  ]
}

sketch.ino

10,859 bytes · ESP32 program

Download

/*
 * Sensor Calibration Workshop
 * Interactive Lab: Two-Point Calibration with Signal Conditioning
 *
 * This code demonstrates:
 * - Raw ADC reading and conversion
 * - Two-point calibration (offset + gain correction)
 * - Simple moving average filter for noise reduction
 * - Interactive calibration procedure
 *
 * Components:
 * - ESP32 DevKit
 * - Potentiometer on GPIO 34 (simulates uncalibrated sensor)
 * - LED on GPIO 2 (calibration status indicator)
 */

// ============ PIN DEFINITIONS ============
const int SENSOR_PIN = 34;    // Analog input (ADC1_CH6)
const int LED_PIN = 2;        // Built-in LED for status

// ============ ADC CONFIGURATION ============
const float ADC_MAX = 4095.0;        // 12-bit ADC resolution (0-4095)
const int FILTER_SIZE = 10;          // Moving average window size

// ============ CALIBRATION VARIABLES ============
float calOffset = 0.0;       // Offset correction (additive)
float calGain = 1.0;         // Gain correction (multiplicative)

// Reference values for two-point calibration
float lowRefActual = 10.0;   // Known low reference (e.g., 10%)
float highRefActual = 90.0;  // Known high reference (e.g., 90%)
float lowRefRaw = 0.0;       // Raw reading at low reference
float highRefRaw = 0.0;      // Raw reading at high reference

// ============ FILTER VARIABLES ============
float filterBuffer[FILTER_SIZE];
int filterIndex = 0;
bool filterFilled = false;

// ============ STATE MACHINE ============
enum CalibrationState {
    NORMAL_MODE,
    WAIT_LOW_POINT,
    WAIT_HIGH_POINT
};

CalibrationState currentState = NORMAL_MODE;
unsigned long lastPrintTime = 0;
const unsigned long PRINT_INTERVAL = 500;

// ============ FUNCTION DECLARATIONS ============
float readRawSensor();
float applyFilter(float newValue);
float applyCalibration(float rawValue);
void calculateCalibrationCoefficients();
void printCalibrationStatus();
void handleSerialCommands();
void blinkLED(int times, int delayMs);

void setup() {
    Serial.begin(115200);
    delay(1000);

// Configure pins
    pinMode(LED_PIN, OUTPUT);
    analogReadResolution(12);  // 12-bit ADC (0-4095)
    analogSetAttenuation(ADC_11db);  // Set 11dB attenuation for full 0-3.3V input range

// Initialize filter buffer
    for (int i = 0; i < FILTER_SIZE; i++) {
        filterBuffer[i] = 0.0;
    }

// Welcome message
    Serial.println("\n========================================");
    Serial.println("   SENSOR CALIBRATION WORKSHOP");
    Serial.println("   Interactive Two-Point Calibration Lab");
    Serial.println("========================================\n");

Serial.println("COMMANDS:");
    Serial.println("  'c' - Start calibration procedure");
    Serial.println("  'l' - Capture LOW reference point");
    Serial.println("  'h' - Capture HIGH reference point");
    Serial.println("  'r' - Reset calibration to defaults");
    Serial.println("  's' - Show current calibration status");
    Serial.println("\nTurn the potentiometer to simulate sensor readings.\n");

// Initial LED flash to indicate startup
    blinkLED(3, 200);
    digitalWrite(LED_PIN, HIGH);  // LED on = normal mode
}

void loop() {
    // Handle serial commands for calibration
    handleSerialCommands();

// Read and process sensor
    float rawPercent = readRawSensor();
    float filteredRaw = applyFilter(rawPercent);
    float calibratedValue = applyCalibration(filteredRaw);

// Print values periodically
    if (millis() - lastPrintTime >= PRINT_INTERVAL) {
        lastPrintTime = millis();

if (currentState == NORMAL_MODE) {
            Serial.print("RAW: ");
            Serial.print(rawPercent, 1);
            Serial.print("%  |  FILTERED: ");
            Serial.print(filteredRaw, 1);
            Serial.print("%  |  CALIBRATED: ");
            Serial.print(calibratedValue, 1);
            Serial.print("%  |  CORRECTION: ");
            Serial.print(abs(filteredRaw - calibratedValue), 2);
            Serial.println("%");
        }
    }

// Update LED based on mode
    if (currentState != NORMAL_MODE) {
        // Blink LED during calibration
        digitalWrite(LED_PIN, (millis() / 250) % 2);
    } else {
        digitalWrite(LED_PIN, HIGH);  // Steady on in normal mode
    }

delay(50);
}

// ============ SENSOR READING ============
float readRawSensor() {
    int rawADC = analogRead(SENSOR_PIN);
    float percent = (rawADC / ADC_MAX) * 100.0;
    return percent;
}

// ============ MOVING AVERAGE FILTER ============
float applyFilter(float newValue) {
    filterBuffer[filterIndex] = newValue;
    filterIndex = (filterIndex + 1) % FILTER_SIZE;

if (filterIndex == 0) {
        filterFilled = true;
    }

int count = filterFilled ? FILTER_SIZE : filterIndex;
    if (count == 0) return newValue;

float sum = 0.0;
    for (int i = 0; i < count; i++) {
        sum += filterBuffer[i];
    }
    return sum / count;
}

// ============ CALIBRATION APPLICATION ============
float applyCalibration(float rawValue) {
    return (rawValue * calGain) + calOffset;
}

// ============ CALIBRATION PROCEDURE ============
void calculateCalibrationCoefficients() {
    if (abs(highRefRaw - lowRefRaw) < 0.001) {
        Serial.println("ERROR: Reference points too close together!");
        return;
    }

calGain = (highRefActual - lowRefActual) / (highRefRaw - lowRefRaw);
    calOffset = lowRefActual - (lowRefRaw * calGain);

Serial.println("\n========================================");
    Serial.println("   CALIBRATION COMPLETE!");
    Serial.println("========================================");
    Serial.print("   Gain (slope):  ");
    Serial.println(calGain, 4);
    Serial.print("   Offset (intercept): ");
    Serial.println(calOffset, 4);
    Serial.println("----------------------------------------");
    Serial.println("   Calibration Equation:");
    Serial.print("   Calibrated = Raw * ");
    Serial.print(calGain, 4);
    Serial.print(" + ");
    Serial.println(calOffset, 4);
    Serial.println("========================================\n");

// Verification
    float verifyLow = applyCalibration(lowRefRaw);
    float verifyHigh = applyCalibration(highRefRaw);

Serial.println("VERIFICATION:");
    Serial.print("   Low point:  Raw=");
    Serial.print(lowRefRaw, 1);
    Serial.print("% -> Calibrated=");
    Serial.print(verifyLow, 1);
    Serial.print("% (Expected: ");
    Serial.print(lowRefActual, 1);
    Serial.println("%)");

Serial.print("   High point: Raw=");
    Serial.print(highRefRaw, 1);
    Serial.print("% -> Calibrated=");
    Serial.print(verifyHigh, 1);
    Serial.print("% (Expected: ");
    Serial.print(highRefActual, 1);
    Serial.println("%)\n");

currentState = NORMAL_MODE;
    blinkLED(5, 100);  // Success indication
}

// ============ SERIAL COMMAND HANDLER ============
void handleSerialCommands() {
    if (Serial.available() > 0) {
        char cmd = Serial.read();

switch (cmd) {
            case 'c':
            case 'C':
                Serial.println("\n========================================");
                Serial.println("   CALIBRATION PROCEDURE STARTED");
                Serial.println("========================================");
                Serial.println("\nStep 1: Set the potentiometer to the LOW reference point");
                Serial.print("        (This represents ");
                Serial.print(lowRefActual, 0);
                Serial.println("% actual value)");
                Serial.println("        Press 'l' when ready to capture.\n");
                currentState = WAIT_LOW_POINT;
                break;

case 'l':
            case 'L':
                if (currentState == WAIT_LOW_POINT) {
                    lowRefRaw = applyFilter(readRawSensor());
                    Serial.print("\nLOW POINT CAPTURED: Raw = ");
                    Serial.print(lowRefRaw, 1);
                    Serial.print("% (Actual = ");
                    Serial.print(lowRefActual, 0);
                    Serial.println("%)\n");

Serial.println("Step 2: Set the potentiometer to the HIGH reference point");
                    Serial.print("        (This represents ");
                    Serial.print(highRefActual, 0);
                    Serial.println("% actual value)");
                    Serial.println("        Press 'h' when ready to capture.\n");
                    currentState = WAIT_HIGH_POINT;
                } else {
                    Serial.println("Press 'c' first to start calibration!");
                }
                break;

case 'h':
            case 'H':
                if (currentState == WAIT_HIGH_POINT) {
                    highRefRaw = applyFilter(readRawSensor());
                    Serial.print("\nHIGH POINT CAPTURED: Raw = ");
                    Serial.print(highRefRaw, 1);
                    Serial.print("% (Actual = ");
                    Serial.print(highRefActual, 0);
                    Serial.println("%)\n");

Serial.println("Calculating calibration coefficients...\n");
                    calculateCalibrationCoefficients();
                } else {
                    Serial.println("Capture low point first with 'l'!");
                }
                break;

case 'r':
            case 'R':
                calOffset = 0.0;
                calGain = 1.0;
                lowRefRaw = 0.0;
                highRefRaw = 0.0;
                currentState = NORMAL_MODE;
                Serial.println("\nCalibration RESET to defaults (gain=1.0, offset=0.0)\n");
                break;

case 's':
            case 'S':
                printCalibrationStatus();
                break;
        }
    }
}

// ============ STATUS DISPLAY ============
void printCalibrationStatus() {
    Serial.println("\n========================================");
    Serial.println("   CURRENT CALIBRATION STATUS");
    Serial.println("========================================");
    Serial.print("   Gain:   ");
    Serial.println(calGain, 4);
    Serial.print("   Offset: ");
    Serial.println(calOffset, 4);
    Serial.println("----------------------------------------");
    Serial.print("   Low Ref:  Raw=");
    Serial.print(lowRefRaw, 1);
    Serial.print("% -> Actual=");
    Serial.print(lowRefActual, 0);
    Serial.println("%");
    Serial.print("   High Ref: Raw=");
    Serial.print(highRefRaw, 1);
    Serial.print("% -> Actual=");
    Serial.print(highRefActual, 0);
    Serial.println("%");
    Serial.println("========================================\n");
}

// ============ LED INDICATOR ============
void blinkLED(int times, int delayMs) {
    for (int i = 0; i < times; i++) {
        digitalWrite(LED_PIN, HIGH);
        delay(delayMs);
        digitalWrite(LED_PIN, LOW);
        delay(delayMs);
    }
}

Use the launch button above to open the ESP32 editor in Wokwi.
Select the editor’s diagram.json tab and replace all its text with the supplied diagram.json.
Select the sketch.ino tab, replace all its text with the supplied sketch.ino, then click Start Simulation.

Steps

Screens captured against Wokwi ESP32 Compiled and booted by the Wokwi gate (ESP32 Arduino core 3.3.11); captured in the Wokwi web editor on 2026-09-09 on 2026-09-09; the tool may have moved on — the text steps are the contract.

Step 1
Do
In Wokwi's project editor, paste diagram.json and sketch.ino into a new Wokwi ESP32 project; inspect the potentiometer and status LED connections.
You will see
LED anode connects to ESP32 GPIO2 (diagram.json line 55). LED cathode returns through ledR to ESP32 ground (diagram.json lines 61, 67). The LED’s series resistor ledR is 220 Ω (diagram.json line 24). Power: potentiometer VCC connects to ESP32 3.3 V; GND returns to ground (diagram.json lines 73, 79). Potentiometer signal connects to ESP32 GPIO34 (diagram.json line 85).
Why it matters
GPIO34 supplies the raw ADC endpoints used later for calibration. The status LED on GPIO2 reports the procedure state through a current-limited path.
Step 2
Do
In the Simulation toolbar, start the run; read steady midpoint values in Serial Monitor.
You will see
Input: supplied potentiometer midpoint. Observed: "RAW: 50.1% | FILTERED: 50.1% | CALIBRATED: 50.1% | CORRECTION: 0.00%". Observed: the same row repeats before calibration. Expected: uncalibrated midpoint has zero correction.
Why it matters
The raw and filtered readings agree at 50.1%. The calibrated value begins at the same value. The correction is zero before reference capture. This is the baseline for the next two points.
Step 3
Do
In the Serial Monitor input field, send c to start the calibration procedure.
You will see
Input: send c. Observed: "CALIBRATION PROCEDURE STARTED". Observed: "Step 1: Set the potentiometer to the LOW reference point". Observed: "(This represents 10% actual value)".
Why it matters
The sketch enters its calibration procedure. It requests the low reference first. The declared actual value is 10%. A reference must be captured before the gain is computed.
Step 4
Do
In the potentiometer control panel, set 153 of 1023; then send l in Serial Monitor.
You will see
Input: potentiometer control 153, then command l. Observed: "LOW POINT CAPTURED: Raw = 14.9% (Actual = 10%)". Observed: the monitor next requests the HIGH reference. Expected: store 14.9% raw as the 10% actual reference.
Why it matters
The sensor model reads above the declared actual low point. The command records both raw and actual values. The later high point is still needed for a two-point fit. The 14.9% value matches the real screenshot.
Step 5
Do
In the potentiometer control panel, set 870 of 1023; then send h in Serial Monitor.
You will see
Input: potentiometer control 870, then command h. Observed: "HIGH POINT CAPTURED: Raw = 85.1% (Actual = 90%)". Observed: "Low point: Raw=14.9% -> Calibrated=10.0% (Expected: 10.0%)". Observed: "High point: Raw=85.1% -> Calibrated=90.0% (Expected: 90.0%)".
Why it matters
The high raw value falls below its declared actual reference. The two captured pairs define a linear correction. Verification maps the low reference to 10.0%. Verification maps the high reference to 90.0%.
Step 6
Do
In the potentiometer control panel, restore 512 and read settled Serial Monitor rows.
You will see
Input: potentiometer control restored to 512. Observed: "RAW: 50.1% | FILTERED: 50.1% | CALIBRATED: 50.1% | CORRECTION: 0.01%". Observed: the settled row repeats. Expected: midpoint returns with a small correction.
Why it matters
The raw and filtered readings settle together. The calibrated reading is 50.1%. The residual correction is 0.01%. This midpoint checks interpolation between references.
Step 7
Do
In the Serial Monitor input field, send r and read the next steady row.
You will see
Input: send r after midpoint has settled. Observed: "Calibration RESET to defaults (gain=1.0, offset=0.0)". Observed: "RAW: 50.1% | FILTERED: 50.1% | CALIBRATED: 50.1% | CORRECTION: 0.00%". Expected: default gain and offset remove the correction.
Why it matters
The gain returns to one. The offset returns to zero. The displayed correction returns to 0.00%. The midpoint remains the same controlled input.

Chapter checks

These questions refer to the chapter’s examples. Use the return links to review their answers.

A sensor reads 20% when the true value is 10%, and reads 80% when the true value is 90%. What is the gain (slope) coefficient?
Return to the chapter’s knowledge check
In the lab code, why is the moving average filter applied BEFORE calibration, not after?
Return to the chapter’s knowledge check

Return to Sensor Calibration: Math and Validation · Browse Labs

Wokwi ESP32

Get the files

diagram.json

sketch.ino

Steps

1 Step 1

2 Step 2

3 Step 3

4 Step 4

5 Step 5

6 Step 6

7 Step 7

Chapter checks

Step 1

Step 2

Step 3

Step 4

Step 5

Step 6

Step 7