Decoding the 10 Microfarad Capacitor Code (106 vs 10u)

When sourcing passive components for embedded timing circuits or power decoupling, you will frequently encounter the 10 microfarad capacitor code printed as 106 on ceramic surface-mount devices (SMDs). This is the EIA (Electronic Industries Alliance) 3-digit marking system. The first two digits represent the significant figures (10), and the third digit is the multiplier in picofarads (pF). Therefore, 106 translates to 10 × 10^6 pF, which equals 10,000,000 pF, or exactly 10 µF.

However, reading the code is only the first step. The real engineering challenge is selecting the right chemistry for your specific embedded application. A 10µF aluminum electrolytic capacitor behaves vastly differently from a 10µF Multi-Layer Ceramic Capacitor (MLCC) under DC bias.

Decision Path: Selecting Your 10µF Capacitor

Application NeedChemistryMarking / CodePros & Cons
High-frequency decoupling, space-constrained SMD boardsMLCC (X5R/X7R)106Low ESR, tiny footprint. Warning: Suffers severe capacitance loss under DC bias (a 10µF X5R might act like 2µF at 5V).
Bulk energy storage, low-frequency analog filteringAluminum Electrolytic10µF (printed)High capacitance stability under bias, cheap. Drawback: High ESR, large through-hole footprint, polarity sensitive.
Space-constrained but requires stable capacitance under biasTantalum106 (often with voltage letter)Stable capacitance, compact. Drawback: Catastrophic failure mode if subjected to reverse voltage or high ripple current.

The Concrete Pick: For general ESP32 power rail decoupling and RC timing circuits where board space is at a premium, default to the Samsung Electro-Mechanics CL21A106KOQNNNG (0805 footprint, X5R, 16V, 106 code). If your circuit requires absolute precision timing without DC bias derating, use a Panasonic EEU-FR1V100 (10µF 35V Aluminum Electrolytic).

Project: ESP32 10µF Verifier Build

Counterfeit and out-of-spec capacitors are a persistent issue in the supply chain. To verify that your '106' MLCCs are actually 10µF (and not mislabeled 1µF parts), we can build an automated RC time-constant verifier using an ESP32. This project charges the capacitor through a known precision resistor and measures the time it takes to reach 63.2% of the supply voltage (one time constant, τ = R × C).

Difficulty: Intermediate | Time: 45 minutes | Target Board: ESP32-WROOM-32 DevKit v1 (30-pin variant)

Parts List

  • Microcontroller: ESP32-WROOM-32 DevKit v1 (30-pin)
  • Display: 0.96-inch SSD1306 I2C OLED (128x64, 4-pin)
  • Resistor: 10kΩ 1% precision metal film (for charge path)
  • Test Capacitor: DUT (Device Under Test) - 10µF (106 code)
  • Jumper wires & breadboard

Pin Mapping Table

ComponentPin / LabelESP32 GPIOFunction
Charge ResistorInput SideGPIO 25Sources 3.3V to begin charging
Discharge PathDirect to Cap (+)GPIO 26Sinks to GND to reset capacitor
ADC MeasureCap (+) NodeGPIO 34Reads analog voltage (Input only)
OLED DisplaySDAGPIO 21I2C Data
OLED DisplaySCLGPIO 22I2C Clock

Compilable ESP32 Verification Code

The following code targets the ESP32-WROOM-32 DevKit v1. It utilizes the Wire and Adafruit_SSD1306 libraries. Ensure you have the Adafruit GFX and SSD1306 libraries installed via the Arduino Library Manager.

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// --- PIN DEFINITIONS ---
#define PIN_CHARGE 25
#define PIN_DISCHARGE 26
#define PIN_MEASURE 34

// --- OLED CONFIG ---
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

const float R_CHARGE = 10000.0; // 10k ohm precision resistor
const int ADC_THRESHOLD = 2586; // 63.2% of 4095 (3.3V logic)

void setup() {
  Serial.begin(115200);
  
  pinMode(PIN_CHARGE, OUTPUT);
  digitalWrite(PIN_CHARGE, LOW);
  
  // Initialize OLED
  if(!display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS)) {
    Serial.println(F('SSD1306 allocation failed or I2C timeout'));
    for(;;); // Halt execution on failure
  }
  
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0,0);
  display.println('ESP32 Cap Verifier');
  display.println('Target: 106 (10uF)');
  display.display();
  delay(1000);
}

void loop() {
  // 1. Discharge Phase
  pinMode(PIN_DISCHARGE, OUTPUT);
  digitalWrite(PIN_DISCHARGE, LOW); // Sink to GND
  delay(500); // Allow 10uF to fully drain
  pinMode(PIN_DISCHARGE, INPUT); // High-Z to stop discharging

  // 2. Charge & Measure Phase
  unsigned long startTime = micros();
  digitalWrite(PIN_CHARGE, HIGH); // Source 3.3V through 10k

  int adcVal = 0;
  unsigned long elapsedTime = 0;
  bool timeout = false;

  while(adcVal < ADC_THRESHOLD) {
    adcVal = analogRead(PIN_MEASURE);
    elapsedTime = micros() - startTime;
    if(elapsedTime > 5000000) { // 5 second safety timeout
      timeout = true;
      break;
    }
  }
  digitalWrite(PIN_CHARGE, LOW); // Stop charging

  // 3. Calculate & Display
  display.clearDisplay();
  display.setCursor(0,0);
  
  if(timeout) {
    display.println('ERROR: Timeout!');
    display.println('Cap > 100uF or');
    display.println('Wiring Fault.');
  } else {
    float t_seconds = elapsedTime / 1000000.0;
    float capacitance = t_seconds / R_CHARGE;
    float uF = capacitance * 1000000.0;
    
    display.println('Code 106 Verified');
    display.print('Measured: ');
    display.print(uF, 2);
    display.println(' uF');
    
    if(uF < 8.0) {
      display.println('WARN: DC Bias Derating');
    }
  }
  display.display();
  delay(2000);
}

Debugging: I2C Errors and ADC Timeouts

When integrating I2C displays and analog timing on the ESP32, hardware hangs are common. If your serial monitor outputs the following exact error string, your I2C bus has locked up:

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

Ranked Causes for I2C Error -1

  1. Missing Pull-up Resistors: The ESP32 internal pull-ups are too weak (~45kΩ) for reliable I2C at 400kHz. The SSD1306 breakout usually has 10kΩ pull-ups onboard, but if you are using a raw module, you must add 4.7kΩ external pull-ups to 3.3V on both SDA and SCL.
  2. Incorrect I2C Address: The code assumes 0x3C. Many 0.96-inch OLEDs ship with 0x3D. Run an I2C scanner sketch to verify the address before compiling the verifier.
  3. SDA/SCL Swap: GPIO 21 is SDA and GPIO 22 is SCL on the standard 30-pin DevKit v1. Swapping them will cause the Wire library to hang indefinitely, eventually triggering a Watchdog Timer (WDT) panic.

The First Three Things to Check When It Fails

If the OLED stays blank or the serial monitor throws the Error -1 string, execute this checklist:

  1. Verify I2C Address: Upload a basic Wire.scan() script. If nothing shows up, your wiring is wrong or the display is dead.
  2. Check Capacitor Discharge Path: If GPIO 26 is accidentally left as an OUTPUT HIGH during the charge phase, it will fight GPIO 25, potentially damaging the ESP32 GPIO pad. Ensure the code explicitly sets it to INPUT before charging.
  3. Inspect ADC Pin: GPIO 34 is input-only. If you accidentally defined an output pin (like GPIO 2) for measurement, the internal drive will override the RC curve, resulting in instant 0.00uF readings.

Extending and Simplifying the Build

Once you have the base verifier running, you can adapt it to your specific bench needs.

How to Extend the Build (Auto-Ranging)

The current build uses a fixed 10kΩ resistor, which is optimized for the 10µF (106) range. To measure smaller ceramic caps (e.g., 104 / 0.1µF), the charge time drops into the microsecond range, where ESP32 micros() resolution and GPIO switching delays introduce massive errors. Extension: Add a CD4051 analog multiplexer to switch between a 10kΩ, 100kΩ, and 1MΩ charge resistor dynamically. Read the ADC; if the threshold isn't reached within 50ms, switch to the next highest resistor via GPIO and restart the timer.

How to Simplify the Build (Headless Mode)

If you are processing a tape-and-reel of 106 capacitors and don't want to wire up an OLED, strip out the Wire.h and Adafruit_SSD1306 dependencies entirely. Replace the display logic with standard Serial.printf('Measured: %.2f uF\n', uF);. This eliminates the I2C bus entirely, removing the risk of Error -1 hangs, and allows you to log the CSV data directly to your PC via the Arduino Serial Plotter for statistical process control (SPC) analysis of your component batch.

For deeper reading on ESP32 I2C bus recovery and MLCC DC bias characteristics, refer to the Random Nerd Tutorials ESP32 I2C Guide and Murata's MLCC DC Bias FAQ.