Kapazität messen mit dem Arduino

In dieser Folge beschäftigen wir uns mit dem Messen von Kondensatoren, also Kapazitäten mit dem Arduino. Ich experimentiere schon seit einiger Zeit damit herum und habe vor ein paar Wochen günstige Arduino-Nano Clones aus China bekommen, mit denen ich nun ein kleines Projekt realisieren wollte.

title_image

Das Messen von Kapazitäten ist hierfür geradezu ideal. Nur wie misst man diese eigentlich? Dazu benötigen wir zunächst ein wenig Theorie, aber keine Angst, es hält sich in Grenzen.

Legt man an an einen Kondensator über einen Vorwiderstand eine Gleichspannung an, so lädt sich dieser nach einer bestimmten Zeit fast vollständig auf die angelegte Spannung auf. Gleichzeitig bezeichnet man diese Art der Schaltung schon als RC-Glied, oder Tiefpass. Die Eigenschaften als Tiefpass wollen uns an dieser Stelle aber nicht weiter interessieren.

RC-Glied

RC-Glied

Nun können wir einige Überlegungen anstellen.

Aus der Elektrotechnik wissen wir schon etwas über die Zeitkonstante "Tau", diese berechnet sich folgendermaßen:

tau = R*C

Diese Zeitkonstante besagt nach welcher Zeit sich der Kondensator auf ca. 63% der angelegten Spannung aufgeladen hat, das können wir also gut gebrauchen. Wie kommen wir denn aber nun auf die Einheit Sekunden? Ganz einfach, die Kapazität in Farad gemessen lässt sich auch schreiben als:

F = frac{A * s}{V}

Und der Widerstand in Omega gemessen ist natürlich laut dem Ohm'schen Gesetz frac{U}{I} also in Einheiten ausgedrückt frac{V}{A}.

Wir erhalten also die Einheit für R*C:

R * C = frac{A * s * V}{V * A}

Ampere(A) und Volt(V) kürzen sich raus und es bleibt nur noch die Sekunde, so ein Zufall!

Rein interessehalber schauen wir uns noch die vollständige Formel an, nach der sich die Spannung U an einem Kondensator zu einem beliebigen Zeitpunkt berechnen lässt, sozusagen die Ladekennlinie des Kondensators:

U(t) = U_{rm max} cdot (1 - e^{-frac{t}{tau}})

Das können wir uns auch mal als Grafik ausgeben, dann wird der Zusammenhang gleich viel klarer (Klicken zum Vergößern).

RC-Glied

RC-Glied

Die beiden gestrichelten Linien zeigen den Punkt an dem sich der Kondensator auf 63% der angelegten Spannung aufgeladen hat, also genau nach 1*Tau (reimt sich).

Natürlich verhält sich ein RC Glied in der Realität fast genauso. Im folgenden Bild habe ich ein RC-Glied mit 100nF und 1kOhm an eine Rechteckspannung mit ca. 250HZ angeschlossen und die Spannung am Kondensator gemessen, hier lässt sich der Lade -und Entladevorgang sehr gut beobachten:

RC-Glied an 250Hz

RC-Glied an 250Hz

Jetzt haben wir unser Handwerkszeug zusammen und können unsere Schaltung entwerfen.

Grundsätzlich müssen wir also einen Kondensator über einen Vorwiderstand aufladen und die Zeit messen, die benötigt wird, um den Kondensator aufzuladen. Weiterhin müssen wir den Kondensator auch entladen können. Also benötigen wir einen Widerstand zum Laden und einen zum Entladen, weiterhin müssen wir den ADC des Arduino bemühen, um die Spannung am Kondensator zu messen. Diese kann natürlich niemals höher als die Betriebssspannung des Arduino werden.

Um die ganze Sache abzurunden, benötigen wir ein Display, in diesem Falle ein HD44780 kompatibles 16x2, um die Messung anzuzeigen und einen Taster, um den Messvorgang starten zu können.

Das führt uns dann zu folgender Schaltung:

Schaltplan für den Kapazitätsmesser

Schaltplan für den Kapazitätsmesser

Der Arduino lädt nun über Pin D13 den Kondensator und misst die Zeit, die dafür benötigt wird. Die Messung der Spannung erfolgt am Pin A0 und die Entladung wird über Pin D10 vorgenommen. An JP3 wird dann der Taster zum Starten der Messung angeschlossen. JP2 dient der Spannungsversorgung, hier werden 5V angeschlossen. Alternativ kann die Schaltung auch über die USB-Buchse des Arduino versorgt werden.

Auf dem Steckbrett aufgebaut könnte das so aussehen:

Schaltung auf dem Steckbrett

Schaltung auf dem Steckbrett

Die eigentliche Messroutine ist erschreckend einfach:

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

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

	elapsedTime = millis() - startTime;
	if (elapsedTime > 1) {  //output only if time was measured

		// convert milliseconds to seconds ( 10^-3 ) and Farads to microFarads ( 10^6 ),  net 10^3 (1000)  
		microFarads = ((float)elapsedTime / resistorValue) * 1000;
        }

Hier wird der Ladepin (D13) auf High Pegel, also 5V gesetzt. Wir starten die Zeitmessung und der Ladevorgang beginnt. Der ADC vom Arduino hat eine Auflösung von 10 Bit, also 1024 Schritte. Somit entsprechen 63.2% etwa frac{5V * 0.632}{5V / 1024} = 647 Schritten.

Warten wir also so lange, bis dieser Wert am ADC erreicht ist, können wir anschliessend die Ladezeit ablesen und unsere Kapazität berechnen (Zeile 12). Dann kann der ermittelte Wert auf dem Display ausgegeben werden.

Der ursprüngliche Source Code stammt von Paul Badger, wurde vom Make Magazin erweitert und von mir noch für das LCD und die Tastensteuerung modifiziert,

Das ist eigentlich auch schon die ganze Zauberei. Natürlich kann man die Schaltung noch verbessern, so lassen sich mit dem 10k Ladewiderstand keine kleinen Kapazitäten < 1µF messen. Hier wäre es wünschenswert die noch freien Pins zu verwenden und den Ladewiderstand automatisch umzuschalten.

Vielleicht schauen wir uns in einer der späteren Folgen an, wie man diese Schaltung auf einer Platine aufbaut und in ein schickes Gehäuse einbaut.

Alle Projektdateien, Quelltexte usw. finden sich hier. Viel Spass beim Nachbauen.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.


*