 Buy Arduino Uno on AliExpress

# Use Arduino Capacitance Meter to Measure Capacitance

Capacitors are used in many circuits where a certain amount of charge is required. Capacitors carry the ability to store charge in the form of electric field b/w its conducting plate. There is also dielectric inside the plates b/w capacitor for enhancing the value of maximum stored charge.

Let’s suppose you are in a situation where you don’t have your multimeter (favorite tool for electronics lovers), but you need to measure the capacitance. What will you do? Basically it is awkward to think of a situation where you have your laptop and Arduino but don't have a multimeter. But this lesson will help you to understand how actually the capacitance can be measured and how Arduino is can be much more useful, thus clearing out your basics.

## Theory behind measuring Capacitance with the Arduino Capacitance meter

We will be using the concept of “how capacitor charges and its equation“ to measure the value of Capacitance. Let's look at the basic equation of Capacitor.

Here time is equal to the Resistance * Capacitance if the voltage of the charging capacitor is 63.2%. So wee will use this condition to find out the value of capacitance when the voltage is 63.2%.

T (Time) = R (Resistance) * C (Capacitance)

The T is the time taken to charge the capacitor from 0 to 63.2% which can easily be measured.

## How is Arduino Helpful in this method

1. It can measure the time required to charge the capacitor from 0 to 63.2%
2. It can measure the current-voltage of the capacitor, that is required for checking whether the capacitor has been charged to 63.2% or not?

## What Type of Pins do Arduino have?

To get familiar with the whole working process of the Arduino Capacitance Meter, you need to know which type of pins does Arduino has?

Pinmode(Pin,INPUT):

It is used for reading value of sensor. We will be setting the discharge pin of the capacitor to INPUT mode for not letting it discharge. This pin offers resistance.

Pinmode(Pin,OUTPUT):

It is used for giving the power supply, that is used for turning On LED. We will be setting Charge Pin to HIGH for charging the capacitor.

## Code for Arduino Capacitance Meter

You can copy the code for Arduino below:

```/*  RCTiming_capacitance_meter
*  Demonstrates use of RC time constants to measure the value of a capacitor
*
* Theory   A capcitor will charge, through a resistor, in one time constant, defined as T seconds where
*    TC = R * C
*
*    TC = time constant period in seconds
*    R = resistance in ohms
*
*    The capacitor’s voltage at one time constant is defined as 63.2% of the charging voltage.
*
*  Hardware setup:
*  Test Capacitor between common point and ground (positive side of an electrolytic capacitor  to common)
*  Test Resistor between chargePin and common point
*  220 ohm resistor between dischargePin and common point
*  Wire between common point and analogPin (A/D input)
*/

#define analogPin      0          // analog pin for measuring capacitor voltage
#define chargePin      13         // pin to charge the capacitor – connected to one end of the charging resistor
#define dischargePin   11         // pin to discharge the capacitor
#define resistorValue  10000.0F   // change this to whatever resistor value you are using
// F formatter tells compliler it’s a floating point value

unsigned long startTime;
unsigned long elapsedTime;
float microFarads;                // floating point variable to preserve precision, make calculations

void setup(){
pinMode(chargePin, OUTPUT);     // set chargePin to output
digitalWrite(chargePin, LOW);

Serial.begin(9600);             // initialize serial transmission for debugging
}

void loop(){
digitalWrite(chargePin, HIGH);  // set chargePin HIGH and capacitor charging
startTime = millis();

while(analogRead(analogPin) < 648){       // 647 is 63.2% of 1023, which corresponds to full-scale voltage
}

elapsedTime= millis() – startTime;
// convert milliseconds to seconds ( 10^-3 ) and Farads to microFarads ( 10^6 ),  net 10^3 (1000)
microFarads = ((float)elapsedTime / resistorValue) * 1000;
Serial.print(elapsedTime);       // print the value to serial port
Serial.print(” mS    “);         // print units and carriage return

Serial.print((long)microFarads);       // print the value to serial port
Serial.println(” microFarads”);         // print units and carriage return
}
else
{
// This is  a workaround because Serial.print will not print floats

Serial.print((long)nanoFarads);         // print the value to serial port
Serial.println(” nanoFarads”);          // print units and carriage return
}

/* dicharge the capacitor  */
digitalWrite(chargePin, LOW);             // set charge pin to  LOW
pinMode(dischargePin, OUTPUT);            // set discharge pin to output
digitalWrite(dischargePin, LOW);          // set discharge pin LOW
while(analogRead(analogPin) > 0){         // wait until capacitor is completely discharged
}

pinMode(dischargePin, INPUT);            // set discharge pin back to input
}
```

## Inside the Coding of Arduino Capacitance Meter

To know what is going inside the code, we just stick to the basic theory part first. I suggest you to remind that part if you suffer from short term memory loss. Coding part is implantation of what the theory said:

There is a statement in the while loop:

```while(analogRead(analogPin) < 648){// 647 is 63.2% of 1023, which corresponds to full-scale voltage}
```

It is for the purpose of not allowing the program to proceed further if the voltage has not reached 63.2%.

Then there is `millis()` function used:

millis() used for measuring the time, it starts measuring the time at the staring of the program:

```elapsedTime = millis() – startTime;
```

Likewise, the above statement has been used effectively to calculate the elapsed time. 