How to Decode and Verify Any Resistor Surface Mount Code with an ESP32

The resistor surface mount code is the alphanumeric marking printed on SMD resistors that tells you their ohmic value. Because SMD parts are too small for standard color bands, manufacturers use 3-digit, 4-digit, or EIA-96 alphanumeric codes. But reading the code is only half the battle on the bench; verifying that the physical part actually matches its marked tolerance requires precision measurement. In this guide, we will break down the decoding rules and build a complete ESP32-based bench tool to decode the marking and physically verify the resistance using a 16-bit ADC.

Decoding the Resistor Surface Mount Code: The Decision Tree

Before you solder, you need to know what you are looking at. The format of the resistor surface mount code directly correlates to the component's tolerance and marking standard. Use this decision path to identify your component:

Bench Tool Parts List and Pin Mapping

The ESP32's internal 12-bit ADC is notoriously non-linear and lacks the precision needed to verify 1% SMD tolerances. To build a reliable verifier, we use an external 16-bit ADC in a voltage divider configuration.

Spec-Sheet Parts List

• MCU: ESP32-WROOM-32 DevKit V1 (Target board variant for the firmware below)
• ADC: ADS1115 16-bit I2C ADC module (Adafruit or generic breakout)
• Display: SSD1306 128x64 I2C OLED (0.96 inch)
• Reference Resistor: 10.0kΩ 0.1% precision metal film resistor (Used as the known R1 in the voltage divider)
• Probes: SMD test tweezers or fine pogo-pin jigs

Pin Mapping Table

Complete ESP32 Firmware: Decode and Measure

This firmware targets the ESP32-WROOM-32 DevKit V1. It reads a 3-digit or 4-digit resistor surface mount code via the Serial Monitor, calculates the theoretical resistance, measures the actual resistance via the ADS1115, and outputs a PASS/FAIL verdict based on a 2% tolerance window. You will need the Adafruit_ADS1X15 library installed.

#include <Wire.h>
#include <Adafruit_ADS1X15.h>

// PIN DEFINITIONS
#define I2C_SDA 21
#define I2C_SCL 22

// VOLTAGE DIVIDER CONSTANTS
const float VCC = 3.30;
const float R_REF = 10000.0; // 10k precision reference resistor (0.1%)
const float TOLERANCE_PCT = 2.0; // Acceptable deviation for PASS/FAIL

Adafruit_ADS1115 ads;

void setup() {
  Serial.begin(115200);
  Wire.begin(I2C_SDA, I2C_SCL);
  
  // Initialize ADS1115 with error handling
  if (!ads.begin(0x48)) {
    Serial.println("FATAL: Failed to initialize ADS1115. Check I2C wiring and ADDR pin.");
    while (1) { delay(100); } // Halt execution
  }
  
  ads.setGain(GAIN_ONE); // 1x gain, +/- 4.096V range (resolution 0.125mV)
  Serial.println("ESP32 SMD Resistor Verifier Ready.");
  Serial.println("Enter 3-digit or 4-digit SMD code (e.g., 103 or 1002):");
}

void loop() {
  if (Serial.available() > 0) {
    String smdCode = Serial.readStringUntil('\n');
    smdCode.trim();
    
    long theoreticalR = decodeSMDCode(smdCode);
    if (theoreticalR < 0) {
      Serial.println("ERROR: Invalid code format. Use 3 or 4 digits.");
      return;
    }
    
    Serial.print("Decoded Theoretical: ");
    Serial.print(theoreticalR);
    Serial.println(" ohms");
    
    // Measure actual resistance
    float actualR = measureResistance();
    Serial.print("Measured Actual: ");
    Serial.print(actualR, 2);
    Serial.println(" ohms");
    
    // Calculate deviation
    float deviation = abs(((float)theoreticalR - actualR) / theoreticalR) * 100.0;
    Serial.print("Deviation: ");
    Serial.print(deviation, 2);
    Serial.println("%");
    
    if (deviation <= TOLERANCE_PCT) {
      Serial.println("VERDICT: PASS");
    } else {
      Serial.println("VERDICT: FAIL (Out of tolerance)");
    }
    Serial.println("-------------------------");
  }
}

long decodeSMDCode(String code) {
  int len = code.length();
  if (len == 3) {
    long sig = code.substring(0, 2).toInt();
    int mult = code.substring(2, 3).toInt();
    return sig * pow(10, mult);
  } else if (len == 4) {
    long sig = code.substring(0, 3).toInt();
    int mult = code.substring(3, 4).toInt();
    return sig * pow(10, mult);
  }
  // EIA-96 requires a 96-element lookup array, omitted here for brevity
  return -1; 
}

float measureResistance() {
  int16_t adc0 = ads.readADC_SingleEnded(0);
  float voltage = ads.computeVolts(adc0);
  
  // Prevent division by zero if probe is open
  if (voltage < 0.01) return 0.0; 
  
  // Voltage divider formula: Vout = Vin * (R2 / (R1 + R2))
  // R2 is our unknown SMD, R1 is the 10k reference
  float r_unknown = R_REF * (voltage / (VCC - voltage));
  return r_unknown;
}

Debugging: First Three Things to Check When It Fails

When working with I2C peripherals on the ESP32, bus lockups and initialization failures are common. If your serial monitor spits out this exact error string during compilation or runtime:

[E][Wire.cpp:400] requestFrom(): i2cWriteReadNonStop returned Error -1

This indicates the ESP32's I2C peripheral failed to receive an ACK from the target device. Here are the first three things to check, ranked by likelihood:

1. Missing Pull-up Resistors or Wrong Address: The ADS1115 breakout usually has 10k pull-ups onboard, but cheap clones often omit them. If your module lacks them, add 4.7kΩ resistors between SDA/SCL and 3.3V. Also, verify the ADDR pin is tied to GND (address 0x48). If it's floating, the address will drift.
2. SDA and SCL Swapped: The ESP32-WROOM-32 DevKit V1 defaults to GPIO 21 for SDA and GPIO 22 for SCL. If you wired them backward, the bus will hang. Swap the physical wires and hit the EN (reset) button.
3. I2C Bus Lockup from Hot-Plugging: If you connected or disconnected the OLED or ADS1115 while the ESP32 was powered, the I2C state machine inside the ESP32 may have locked up. The Wire library cannot always recover from this. You must physically remove power (unplug USB) for 5 seconds to clear the latch-up state.

For deeper architectural insights into the ESP32's I2C peripheral limitations, refer to the Espressif I2C API Reference.

Extending and Simplifying the Build

Depending on your bench needs, you might want to scale this project up or strip it down.

How to Simplify (The 5% Tolerance Checker)

If you only need to verify 5% tolerance SMD resistors (3-digit codes) and don't care about 1% precision, drop the ADS1115 and the OLED entirely. Wire the voltage divider directly to GPIO 34 on the ESP32. Use the built-in analogRead(34) function. The internal 12-bit ADC has a non-linearity of about ±3%, which is perfectly adequate for passing/failing a 5% SMD part, saving you $6 in components and 20 minutes of wiring.

How to Extend (Auto-Ranging Bench Meter)

To measure SMD resistors from 1Ω to 1MΩ accurately, a single 10k reference resistor won't cut it; the voltage divider resolution collapses at the extremes. Extend the build by adding a 4-channel I2C relay module or a CD4052 multiplexer. Wire four different precision reference resistors (100Ω, 1kΩ, 10kΩ, 100kΩ) and have the ESP32 switch the active reference based on an initial coarse reading. For the ADC specifications and gain settings required for low-ohm measurements, consult the TI ADS1115 Datasheet.

Final Bench Verdict: Which Tolerance to Stock

When ordering SMD resistor kits for your lab, the resistor surface mount code format should dictate your purchasing decision. Here is the definitive stocking decision path:

• IF you are designing high-speed digital logic or basic LED drivers AND cost is the primary constraint → Choose 5% (3-digit code).
• IF you are building analog sensor front-ends, feedback loops, or precision dividers AND you want to avoid keeping two separate inventories → Choose 1% (4-digit code).
• IF you are doing high-density RF or ultra-compact wearable designs AND board space is below 0402 → Choose EIA-96 (2-digit + letter).