1 uF Capacitor Code (105): MLCC Derating and ESP32 Verification Tool

If you are sorting through your bench components looking for a 1 uF ceramic capacitor, the 1 uF capacitor code you need to look for is 105. This three-digit EIA (Electronic Industries Alliance) marking translates to 10 followed by 5 zeros in picofarads (10,000,000 pF), which equals exactly 1 microfarad (1 uF).

However, grabbing a '105' MLCC (Multi-Layer Ceramic Capacitor) and dropping it into an embedded power rail or reset circuit without further thought is a classic hardware debugging trap. In the real world, a 1 uF X7R capacitor operating at 5V might only deliver 0.4 uF of actual capacitance due to DC bias derating. When your ESP32 brownout detector trips or your RC reset circuit fails to hold the EN pin high long enough, the physical component is rarely what the datasheet promised.

This guide breaks down the EIA coding system, exposes the DC bias derating trap, and provides a complete ESP32-based RC timing project so you can measure and verify the true capacitance of your '105' components right at your workbench.

The 1 uF Capacitor Code (105) and the DC Bias Trap

The EIA 3-digit code is standard for SMD and small through-hole ceramic capacitors. The first two digits are the significant figures, and the third digit is the multiplier (number of zeros) in picofarads. While identifying the 1 uF capacitor code (105) is straightforward, understanding how it behaves under voltage is where embedded engineers earn their keep.

Class II dielectrics (like X7R and X5R) are highly voltage-dependent. As the DC voltage across the capacitor increases, the dielectric's permittivity drops, shrinking the effective capacitance. If you use a 1 uF 0805 X7R capacitor to filter a 5V rail for an MLCC decoupling application, you might lose over 60% of your nominal value.

Project Build: ESP32 RC Timing Capacitance Meter

To debug suspect '105' capacitors, we will build a simple RC (Resistor-Capacitor) timing meter using an ESP32-WROOM-32 DevKit V1. By measuring the exact time it takes for a capacitor to charge through a known 10k resistor to the ESP32's digital logic HIGH threshold, we can calculate the true capacitance. This relies on the ESP32 GPIO timing capabilities and bypasses the non-linear internal ADC entirely.

Parts List

• Microcontroller: ESP32-WROOM-32 DevKit V1 (30-pin or 38-pin variant)
• Resistor: 10kΩ 1/4W Metal Film (1% tolerance preferred for measurement accuracy)
• Test Subject: Suspect 1 uF (105) MLCC or electrolytic capacitor
• Hardware: Half-size breadboard, male-to-female jumper wires

Pin Mapping Table

Wiring Steps

1. Insert the 10kΩ resistor into the breadboard. Connect one end to GPIO 16.
2. Insert the capacitor. Connect its positive/first lead to the other end of the 10kΩ resistor (the RC junction).
3. Connect GPIO 18 directly to this same RC junction to monitor the voltage.
4. Connect the second lead of the capacitor to GPIO 17. (Note: We use GPIO 17 instead of hardwiring to GND so the ESP32 can actively discharge the capacitor by pulling GPIO 17 LOW).
5. Connect the breadboard ground rail to the ESP32 GND pin.

Complete ESP32 Arduino Code with Error Handling

The code below targets the ESP32 DevKit V1. It uses micros() to measure the charge time. The ESP32 registers a digital HIGH at approximately 75% of VCC (roughly 2.47V on a 3.3V rail). The math constant 1.386 represents -ln(1 - 0.75), derived from the standard RC charging equation V(t) = Vcc(1 - e^(-t/RC)).

#define CHARGE_PIN   16
#define DISCHARGE_PIN 17
#define MEASURE_PIN  18
#define RESISTOR_OHMS 10000.0
#define TIMEOUT_US   5000000 // 5 second timeout to prevent WDT

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("ESP32 RC Capacitance Meter (Targeting 105 / 1uF)");
  
  pinMode(CHARGE_PIN, OUTPUT);
  pinMode(DISCHARGE_PIN, OUTPUT);
  pinMode(MEASURE_PIN, INPUT);
  
  digitalWrite(CHARGE_PIN, LOW);
  digitalWrite(DISCHARGE_PIN, LOW); // Connects cap to GND
}

void loop() {
  // 1. Discharge the capacitor completely
  digitalWrite(CHARGE_PIN, LOW);
  digitalWrite(DISCHARGE_PIN, LOW);
  delay(50); 
  
  // 2. Prepare for charge cycle
  digitalWrite(DISCHARGE_PIN, HIGH); // High-Z/High to stop GND path (or use INPUT)
  pinMode(DISCHARGE_PIN, INPUT); // Truly high impedance
  
  // 3. Start charging and timing
  unsigned long startTime = micros();
  digitalWrite(CHARGE_PIN, HIGH);
  
  // 4. Wait for logic HIGH threshold (~2.47V) with timeout error handling
  while (digitalRead(MEASURE_PIN) == LOW) {
    if ((micros() - startTime) > TIMEOUT_US) {
      Serial.println("ERROR: Timeout exceeded. Capacitor too large or wiring fault.");
      digitalWrite(CHARGE_PIN, LOW);
      pinMode(DISCHARGE_PIN, OUTPUT);
      digitalWrite(DISCHARGE_PIN, LOW);
      delay(2000);
      return; // Exit loop early to feed watchdog
    }
  }
  
  unsigned long elapsedTime = micros() - startTime;
  
  // 5. Calculate Capacitance
  // t = -R * C * ln(1 - Vth/Vcc)  =>  C = t / (R * 1.386)
  double capacitanceFarads = elapsedTime / (RESISTOR_OHMS * 1.386);
  double capacitanceMicrofarads = capacitanceFarads * 1000000.0;
  
  Serial.print("Measured Time: ");
  Serial.print(elapsedTime);
  Serial.print(" us | Calculated Capacitance: ");
  Serial.print(capacitanceMicrofarads, 3);
  Serial.println(" uF");
  
  // 6. Discharge before next read
  digitalWrite(CHARGE_PIN, LOW);
  pinMode(DISCHARGE_PIN, OUTPUT);
  digitalWrite(DISCHARGE_PIN, LOW);
  
  delay(1000);
}

Debugging: Watchdog Timeouts and Measurement Failures

If you run older or poorly written RC timing code on an ESP32 without a timeout mechanism, and you accidentally test a massive electrolytic capacitor instead of your 1 uF (105) MLCC, the while() loop will block the CPU indefinitely. This starves the FreeRTOS IDLE task, resulting in a hard crash. The exact serial monitor output will be:

E (5000) task_wdt: Task watchdog got triggered. The following tasks did not reset the watchdog in time:
E (5000) task_wdt: - IDLE (CPU 1)
E (5000) task_wdt: Tasks currently running:
E (5000) task_wdt: - loopTask (CPU 1)
Guru Meditation Error: Core 1 panic'ed (Interrupt wdt timeout on CPU1)

The code provided above prevents this via the TIMEOUT_US check, but if you encounter erratic readings or failures, here are the first three things to check:

1. Verify the Resistor Value: Use your multimeter to measure the actual resistance of your '10k' resistor. If it is a 100k or 1k by mistake, your calculated capacitance will be off by a factor of 10. Update the RESISTOR_OHMS constant in the code to match your multimeter reading.
2. Check for Breadboard Parasitics: Breadboards introduce roughly 2pF to 5pF of stray capacitance per contact. While negligible for a 1 uF (1,000,000 pF) capacitor, if you are trying to measure tiny 22pF (220 code) caps with this same setup, parasitics will ruin your data. Keep leads short.
3. Confirm the Discharge Path: If your readings are consistently higher than expected and climbing over successive loops, GPIO 17 is not properly discharging the capacitor. Ensure pinMode(DISCHARGE_PIN, OUTPUT) and digitalWrite(DISCHARGE_PIN, LOW) are executing before the charge cycle begins.

Extending and Simplifying the Build

Depending on your bench needs, you might want to adapt this circuit.

How to Extend the Build

To turn this into a standalone bench tool, add an SSD1306 I2C OLED display (0.96 inch). Wire SDA to GPIO 21 and SCL to GPIO 22. Use the Adafruit_SSD1306 library to print the calculated microfarads directly to the screen, eliminating the need for a serial monitor. You can also add a MOSFET discharge circuit for measuring large electrolytic capacitors (e.g., 1000 uF), as the ESP32's internal GPIO protection diodes cannot safely dissipate the energy of a large charged cap repeatedly.

How to Simplify the Build

If you do not want to write code or use a microcontroller, you can achieve a similar '105' verification using a NE555 timer in astable mode. By placing the 1 uF capacitor in the timing network with a known resistor, the output frequency on Pin 3 will be f = 1.44 / ((R1 + 2*R2) * C). Measure the frequency with a multimeter's Hz setting or an oscilloscope, and solve for C. It requires no firmware, though it lacks the precise microsecond resolution of the ESP32's micros() function.