Decoding the 1 Microfarad Capacitor Code (105) and Verifying It with ESP32

When you pull a small, brown ceramic capacitor from a bin, you will rarely see "1µF" printed on it. Instead, you will see a three-digit EIA marking. If you are searching for the 1 microfarad capacitor code, the direct answer is 105. This translates to 10 × 10⁵ picofarads, which equals 1,000,000 pF, or exactly 1 microfarad (1µF).

However, reading the code is only half the battle. Cheap MLCC (Multi-Layer Ceramic Capacitor) batches frequently suffer from manufacturing drift, and high-k dielectrics like Y5V can lose up to 80% of their capacitance under DC bias. To actually trust the component on your bench, you need to measure it. Below is a complete, decision-forward guide to building an ESP32-based RC-timing capacitance verifier, debugging the inevitable hardware faults, and selecting the exact right 1µF part for your next PCB.

The Physical "105" Marking and DC Bias Derating

The Electronic Industries Alliance (EIA) 3-digit code is standard across ceramic and film capacitors. The first two digits are the significant figures, and the third digit is the multiplier (number of zeros). For a 1µF capacitor:

• Significant figures: 10
• Multiplier: 5 (meaning add five zeros)
• Math: 100,0000 pF = 1,000,000 pF = 1,000 nF = 1µF

You will often see a letter trailing the code, such as 105K. The "K" denotes a ±10% tolerance (M is ±20%, J is ±5%).

Parts List and Pin Mapping for the ESP32 Tester

To verify the physical capacitor, we will build an RC (Resistor-Capacitor) charge-timing circuit. The ESP32 will charge the capacitor through a known precision resistor and use the micros() function to measure exactly how long it takes the voltage to cross the GPIO digital HIGH threshold (approximately 75% of VCC). By applying the natural logarithm of the RC time constant, we can calculate the true capacitance.

Target Board Variant: ESP32 DevKit V1 (30-pin, ESP32-WROOM-32 module). Do not use the ESP32-C3 or S3 variants for this specific code without adjusting the GPIO threshold constants, as their input trip voltages differ.

ESP32 Pin Mapping

Note: We use GPIO 34 for sensing because it is an input-only pin on the ESP32, meaning it lacks internal pull-up/pull-down resistors that would skew our RC timing calculations. For more on ESP32 GPIO architectures, refer to the Espressif GPIO API Reference.

Complete ESP32 C++ Verification Code

The following code is fully compilable in the Arduino IDE (ensure the "ESP32 Dev Module" board is selected). It handles the charge/discharge cycle, calculates the capacitance in microfarads, and cross-references the expected EIA code. It includes explicit timeout error handling to prevent the watchdog from resetting the board if a capacitor is missing.

// 1 Microfarad Capacitor Code (105) Verifier
// Target: ESP32 DevKit V1 (30-pin)

#define PIN_CHARGE    26
#define PIN_DISCHARGE 27
#define PIN_SENSE     34

// 10k Ohm charge resistor in Ohms
#define R_CHARGE      10000.0 

// ESP32 GPIO digital HIGH threshold is approx 75% of VCC (3.3V)
// V(t) = Vcc * (1 - e^(-t/RC)) -> 0.75 = 1 - e^(-t/RC) -> t = 1.386 * RC
#define THRESHOLD_CONSTANT 1.386 

// Timeout in microseconds (10 seconds max)
#define TIMEOUT_US    10000000 

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("--- ESP32 Capacitance Meter & 105 Code Verifier ---");
  
  pinMode(PIN_CHARGE, OUTPUT);
  pinMode(PIN_DISCHARGE, OUTPUT);
  pinMode(PIN_SENSE, INPUT);
  
  // Ensure safe initial state
  digitalWrite(PIN_CHARGE, LOW);
  digitalWrite(PIN_DISCHARGE, LOW);
}

void dischargeCapacitor() {
  digitalWrite(PIN_CHARGE, LOW);
  digitalWrite(PIN_DISCHARGE, LOW); // Discharge through 1k resistor to GND
  delay(500); // Wait 500ms to ensure full bleed
  digitalWrite(PIN_DISCHARGE, HIGH); // Float the discharge path
}

void loop() {
  dischargeCapacitor();
  
  unsigned long startTime = micros();
  unsigned long elapsedTime = 0;
  bool timeout = false;
  
  // Begin charging
  digitalWrite(PIN_CHARGE, HIGH);
  
  // Wait for GPIO 34 to read HIGH
  while (digitalRead(PIN_SENSE) == LOW) {
    elapsedTime = micros() - startTime;
    if (elapsedTime > TIMEOUT_US) {
      timeout = true;
      break;
    }
  }
  
  // Stop charging
  digitalWrite(PIN_CHARGE, LOW);
  
  if (timeout) {
    Serial.println("[ERR] ADC Timeout - Cap > 10uF or Open Circuit");
  } else {
    // Calculate Capacitance: C = t / (1.386 * R)
    // elapsedTime is in microseconds (10^-6), R is in Ohms
    // Resulting C will be in Farads. Multiply by 1,000,000 to get uF.
    double capacitance_uF = (double)elapsedTime / (THRESHOLD_CONSTANT * R_CHARGE);
    
    Serial.print("Measured Time: ");
    Serial.print(elapsedTime);
    Serial.print(" us | Calculated Capacitance: ");
    Serial.print(capacitance_uF, 3);
    Serial.println(" uF");
    
    // Verify against 1 microfarad capacitor code (105) expectations
    if (capacitance_uF >= 0.85 && capacitance_uF <= 1.15) {
      Serial.println("[PASS] Matches EIA Code 105 (1uF +/- 10%)");
    } else if (capacitance_uF >= 0.40 && capacitance_uF < 0.85) {
      Serial.println("[WARN] Low Reading: Possible DC Bias Derating or Y5V Dielectric");
    } else {
      Serial.print("[FAIL] Does not match 105. Expected ~1.000 uF. Check EIA code on casing.");
    }
  }
  
  Serial.println("-------------------------------------------");
  delay(2000); // Pause before next test
}

Debugging: First Three Checks and "Error: ADC Timeout"

When working with RC timing on a breadboard, parasitic resistance and loose contacts are your primary enemies. If your Serial Monitor outputs the exact error string:

[ERR] ADC Timeout - Cap > 10uF or Open Circuit

Do not immediately assume the ESP32 is broken. Follow this ranked troubleshooting path.

The First Three Things to Check

1. Verify Breadboard Continuity (Open Circuit): The most common cause of a timeout is the sense pin (GPIO 34) not actually touching the capacitor leg. Use a digital multimeter in continuity (beep) mode. Place one probe on the ESP32 GPIO 34 header pin and the other on the capacitor leg. If it does not beep, move the capacitor to a different breadboard row.
2. Measure the Charge Resistor: Pull the 10kΩ resistor out of the board and measure it with your DMM. If you accidentally grabbed a 1MΩ resistor, the RC time constant for a 1µF cap becomes 1.38 seconds, which might pass, but if the cap is slightly larger, it will exceed the threshold logic or introduce massive parasitic leakage errors. It must read between 9.9kΩ and 10.1kΩ.
3. Inspect the Physical EIA Code: Are you testing a 106 (10µF) instead of a 105 (1µF)? A 10µF capacitor charging through 10kΩ will take roughly 138 milliseconds to hit the threshold. While this is under the 10-second timeout, a faulty breadboard contact combined with a larger cap will easily trigger the timeout.

Ranked Causes for Measurement Drift (Reads 0.4µF instead of 1.0µF)

If the code compiles and runs, but a known-good "105" capacitor reads as 0.42µF, you are experiencing DC Bias Derating or dielectric absorption. The capacitor is physically 1µF at 0V, but the ESP32 is charging it to 2.5V (the GPIO trip point). If the capacitor uses a low-grade Y5V or Z5U dielectric, its capacitance collapses as voltage increases. Fix: Replace the DUT with an X7R or C0G/NP0 variant.

Decision Tree: Choosing the Right 1µF Capacitor

Not all "105" capacitors are interchangeable. Use this decision matrix to terminate your part selection process with a concrete pick.

The Default Recommendation: If you are building an embedded sensor node, an Arduino shield, or an ESP32 IoT device and need a 1µF bypass/decoupling capacitor, stop searching and buy the Murata GRM21BR71H105KA88. It is an 0805 X7R MLCC rated for 50V. The high voltage rating ensures you stay far below the DC bias derating cliff, guaranteeing you actually get 1µF of capacitance in a live 3.3V or 5V circuit.

Extending and Simplifying the Build

The RC-timing method used above is highly effective for 0.1µF to 10µF ranges. Here is how to adapt the project based on your bench constraints.

How to Simplify (No Precision Resistors)

If you do not have a 1% tolerance 10kΩ metal film resistor, you can use a standard 5% carbon film resistor, but you must measure its exact resistance with a multimeter and update the #define R_CHARGE value in the C++ code. If your DMM reads 9850Ω, change the code to #define R_CHARGE 9850.0. The math relies entirely on the exact resistance value; the ESP32 timing is accurate to the microsecond.

How to Extend (Adding an I2C OLED Display)

To make this a standalone bench tool without a PC tether:

1. Add a 0.96" SSD1306 I2C OLED display.
2. Wire SDA to GPIO 21 and SCL to GPIO 22.
3. Include the Adafruit_SSD1306 and Adafruit_GFX libraries.
4. Replace the Serial.print() statements in the loop() with display.println() calls.
5. Add a physical momentary pushbutton on GPIO 15 (with a 10k pull-down) to trigger the dischargeCapacitor() and measurement cycle only when pressed, saving battery life if you move to a LiPo power setup.

By understanding both the physical EIA "105" stamp and the embedded logic required to verify it, you eliminate the guesswork from your component bin. Always trust the math, verify the dielectric, and measure the threshold.