Arduino Capacitance Meter

Capacitance Meter, as the name suggests, is a device that is used to measure the Capacitance of a Capacitor. There are many Capacitance Meters available in the market but we have built an Arduino Capacitance Meter in this project.

A Capacitor is an electrical device that stores electric charge and this ability of the capacitor to store the electric charge is known as its Capacitance. With the help of a Capacitance Meter, we can measure the rate of charge storage of the capacitor and based on this, we can get the Capacitance of the Capacitor.

Simple Digital Multimeters (DMMs) cannot measure the capacitance and in order to find the capacitance, you either need to go for an advanced, expensive DMM or find a dedicated Capacitance modules.

The dedicated capacitance meters often come with a wide range of measurements of different parameters like Capacitance, inductance, resistance, hFE of a transistor etc.

In this project, we will try to build a simple Arduino Capacitance Meter for two different ranges of capacitances. One circuit will be used to measure a capacitance in the range of 1 µF to 4700 µF. The other circuit will be used to measure smaller capacitance i.e. in the range of 20 pF to 1000 nF.

Warning: If you want measure the capacitance from an old circuit or board, be careful as a capacitor in working condition may store charge even if the power supply is removed. Discharge the capacitor properly before touching it.

Capacitance Meter for Range 1 µF to 4700 µF

Circuit Diagram

Components Required

• Arduino UNO
• 16 x 2 LCD Display
• 10 KΩ Potentiometer
• 10 KΩ Resistor (1/4 Watt)
• 220 Ω Resistor (1/4 Watt)
• Breadboard
• Connecting wires
• Power supply
• Capacitor under test

Working Principle

In order to measure the capacitance in the range of 1 µF to 4700 µF, we have to use the above circuit. Before explaining the working of the project, we will first see the principle behind this method of capacitance measurement.

The principle behind this capacitance meter lies in one of the basic property of the capacitor: The Time Constant. Time Constant (denoted by Greek Alphabet Tau – τ) is defined as the time taken to charge a capacitor (C) through a resistor (R) to reach 63.2 % of the maximum supply voltage.

Alternatively, the Time Constant (τ) of a capacitor can also be defined as the time taken by a fully charged capacitor C to discharge to 36.8 % of its maximum voltage through a resistor R.

Smaller capacitors will have less time constant as they take less time to charge. Similarly, larger capacitors will have higher time constants.

Mathematically, Time Constant TC or τ = R x C (τ = RC).

Here, τ or TC is the time constant of Capacitor in seconds (s), C is the Capacitance of the Capacitor in Farads (F) and R is the Resistance of the Resistor in Ohms (Ω).

The following circuit and graph will show you the time constant curve for a Capacitor C, charging to supply voltage V through a Resistor R.

We use the same concept in our Arduino based Capacitance Meter. We will charge an unknown capacitor through a known resistance using Arduino pins and calculate the time it takes to reach 63.2 % of supply voltage (3.1 V approximately). Based on the time, we can calculate the Capacitance from the formula C = τ / R.

We will use a 10 KΩ Resistor to charge the capacitor and a 220 Ω Resistor to discharge it. The charge and discharge pins on Arduino are 8 and 9 respectively. The voltage across the capacitor is measured using the Analog Input pin A0.

Initially, we will discharge the capacitor using pin 9 (by setting it as OUTPUT and LOW) to make sure that the capacitor has no charge. We will then start the timer and charge capacitor using the charge Pin8 (by setting it as OUTPUT and HIGH).

Now, we have to monitor the voltage across the capacitor at the analog pin and once it reaches 63.2% of 5V (approximately 648 from analog pin), we have to stop the timer and calculate the capacitance.

This circuit is suitable for comparatively higher capacitance values as we can clearly measure the time constant. For smaller capacitance values, this circuit might not be suitable.

Code

	#include <LiquidCrystal.h>
	LiquidCrystal lcd(6, 7, 2, 3, 4, 5);
	int charge = 8;
	int discharge = 9;
	int analogPin = A0;
	unsigned long start_timer=0;
	unsigned long stop_timer=0;
	unsigned long duration=0;
	////////////////////////////////
	float voltage=3;
	float answer=0.0;
	int measure (void);
	/////////////////////////////////
	void setup()
	{
	Serial.begin(9600);
	lcd.begin(16, 2);
	lcd.print("RANGE 1uF-4700uF");
	lcd.setCursor(0,1);
	lcd.print("place capacitor ");
	pinMode(discharge,INPUT);
	pinMode(charge,OUTPUT);
	digitalWrite(charge,HIGH);
	}
	//1021 1022 1023
	void loop()
	{
	while(measure()>=1010 && measure()<=1030)
	{
	lcd.setCursor(0,1);
	lcd.print("place capacitor ");
	delay(200);
	lcd.setCursor(0,1);
	lcd.print(" ");
	delay(200);
	}
	delay(2000);
	lcd.setCursor(0,1);
	lcd.print(" ");
	while(1)
	{
	//////////////////////////////////////////////discharging
	pinMode(charge,INPUT);
	pinMode(discharge,OUTPUT);
	digitalWrite(discharge,LOW);
	lcd.setCursor(0,1);
	lcd.print("Discharging-");//12
	while(voltage>2.0)
	{
	voltage=measure();
	delay(100);
	lcd.setCursor(12,1);
	answer=voltage * (99.0 / 1023.0);
	lcd.print((99-answer),0);
	lcd.setCursor(14,1);
	lcd.print("%");
	}
	lcd.setCursor(0,1);
	lcd.print(" ");
	delay(1000);
	lcd.setCursor(0,1);
	lcd.print("charging-");//9
	lcd.setCursor(13,1);
	lcd.print("%");
	//////////////////////////////////////////////charging
	pinMode(discharge,INPUT);
	pinMode(charge,OUTPUT);
	digitalWrite(charge,HIGH);
	start_timer=micros();
	while(measure()<648)
	{
	lcd.setCursor(9,1);
	lcd.print(measure()*(100.0/1023.0),1);
	}
	stop_timer=micros();
	duration=stop_timer-start_timer;
	answer=duration/10000;
	lcd.clear();
	// lcd.setCursor(0,1);
	// lcd.print(" ");
	lcd.setCursor(0,0);
	lcd.print("value = ");
	lcd.print(answer);
	lcd.print("uF");
	delay(3000);
	while(1)
	{
	lcd.setCursor(0,1);
	lcd.print("reset to measure");
	delay(200);
	lcd.setCursor(0,1);
	lcd.print(" ");
	delay(200);
	}
	}
	}
	int measure (void)
	{
	int value;
	value=analogRead(analogPin);
	return value;
	}

Capacitance Meter for Range 20 pF to 1000 nF

Circuit Diagram

Components Required

• Arduino UNO
• 16 x 2 LCD Display
• 10 KΩ Potentiometer
• Capacitor under test
• Connecting wires
• Breadboard
• Power supply

Working Principle

For measuring smaller capacitances, we will use a different concept. For this we need to understand a little bit about the internal structure of ATmega328P.

All the I/O ports in ATmega328P Microcontroller have an internal pull – up resistor and an internal capacitor connected between the pin and ground. The following image shows the partial internal circuit of an I/O pin of ATmega328P Microcontroller.

We will be using the internal pull – up resistor and the stray capacitor in this circuit. Ignoring the diodes in the above circuit, the circuit for our project can be redrawn as follows.

Here, CT is the capacitor under test and CI is the internal capacitor. We need not worry about the internal capacitor and its value can be anywhere between 20 pF to 30 pF. The unknown capacitor is connected between A2 and A0 (Positive lead to A0, in case of polarized capacitor). Here, A2 acts as the charging pin and A0 acts as the discharging pin.

Initially, we will charge the unknown capacitor by setting A2 as HIGH and measure the voltage at A0 from the following formula.

VA0 = (VA2 X CT)/(CT+CI)

But we already know voltage at A0 with the help of analog read function. Hence, using that value in the above equation, we can get the unknown capacitance as follows.

CT = (CI X VA0)/(VA2-VA0 )

Code

	#include <LiquidCrystal.h>
	LiquidCrystal lcd(6, 7, 2, 3, 4, 5);
	const int analog_charge = A2;
	const int analogPin = A0;
	float ck=24.42;
	int voltage;
	float cu;
	void setup()
	{
	Serial.begin(9600);
	lcd.begin(16, 2);
	lcd.print(" 20pF<to>1000nF ");
	lcd.setCursor(0,1);
	lcd.print("place capacitor ");
	pinMode(analogPin,OUTPUT);
	pinMode(analog_charge,OUTPUT);
	}
	void loop()
	{
	abc:
	pinMode(analogPin,INPUT);
	digitalWrite(analog_charge,HIGH);
	voltage=analogRead(analogPin);
	digitalWrite(analog_charge,LOW);
	//analog_charge = 998 || 999 || 1000 || 1001 and ! 1024
	pinMode(analogPin,OUTPUT);
	if(voltage<1000)
	{
	cu=((ck*voltage)/(1024.0-voltage));
	if(cu>20.0)
	{
	lcd.setCursor(0,1);
	lcd.print(" ");
	lcd.setCursor(0,1);
	lcd.print(cu,2);
	lcd.print("pF");
	}
	else
	{
	lcd.setCursor(0,1);
	lcd.print("place capacitor ");
	delay(200);
	lcd.setCursor(0,1);
	lcd.print(" ");
	delay(200);
	goto abc;
	}
	}
	else
	{
	voltage=0;
	pinMode(analogPin,OUTPUT);
	delay(1);
	pinMode(analog_charge,INPUT_PULLUP);
	unsigned long start_time = micros();
	unsigned long final_time=0;
	while((voltage < 1) && (final_time < 400000L))
	{
	voltage = digitalRead(analog_charge);
	unsigned long stop_time = micros();
	final_time = stop_time > start_time ? stop_time - start_time : start_time - stop_time;
	}
	pinMode(analog_charge, INPUT);
	voltage = analogRead(analog_charge);
	digitalWrite(analogPin, HIGH);
	int delay_T = (int)(final_time / 1000L) * 5;
	delay(delay_T);
	pinMode(analog_charge, OUTPUT);
	digitalWrite(analog_charge, LOW);
	digitalWrite(analogPin, LOW);
	cu = -(float)final_time / 34.8 ;
	cu /= log(1.0 - (float)voltage / (float)1023);
	if(cu < 1000.0)
	{
	lcd.setCursor(0,1);
	lcd.print(" ");
	lcd.setCursor(0,1);
	lcd.print(cu,2);
	lcd.print("nF");
	}
	else
	{
	lcd.setCursor(0,1);
	lcd.print(" ");
	lcd.setCursor(0,1);
	lcd.print("**Out of Range**");
	}
	}
	delay(1000);
	}

Advantages

• It is a simple Arduino based Capacitance Meter with very less hardware requirements.
• The project can be used to measure any capacitance within the range of 20 pF to 4700 µF.

Disadvantages

• Results might not be accurate.
• For accurate results, it is suggested to go for DMMs which can measure capacitance.

Applications

• Capacitance Meter can be used to measure capacitance of unknown capacitors.
• Using Arduino for Capacitance Meter makes it easy to implement the project and with slight modifications, the circuit can be made for a wide range of capacitors.