Arduino als Kapazitätsmessgerät

Einführung

Willkommen auf meiner Seite – schön, dass du da bist! Diese Seite ist noch in Bearbeitung...

In diesem Beitrag soll gezeigt werden, wie mit einem Arduino zusammen mit einem astabilen Multivibrator ein Messgerät entwickelt werden kann, mit dessen Hilfe Kapazitäten von 10 nF bis 1 µF gemessen werden können. Dazu wird ein Rechteckgenerator verwendet, dessen Rechtecksignal von einem RC-Glied abhängt. Die Taktzeit des Rechtecksignals wird über die pulseIn(pin, HIGH/LOW, timeout)-Funktion des Arduino gemessen. Sie wartet auf eine Flanke am Eingang und misst die Dauer des folgenden Pegels in Mikrosekunden.

int pin = 7;
unsigned long dauer;

void setup() {
  Serial.begin(9600);
  pinMode(pin, INPUT);
}

void loop() {
  dauer = pulseIn(pin, HIGH);   // Dauer des HIGH-Pegels in µs
  Serial.println(dauer);
}

Für den Rechteckgenerator eignet sich der IC NE555 sehr gut, da er nur wenige zusätzliche Bauteile benötigt. Für die Funktionsweise sind im Wesentlichen die Bauteile R1, R2 und C1 verantwortlich. Der Kondensator C2 dient der Entkopplung (Rauschunterdrückung).

Funktionsprinzip

Der NE555 ist als astabile Kippstufe geschaltet. Um möglichst symmetrische Signallaufzeiten ($t_\text{low} \approx t_\text{high}$) zu erreichen, werden z. B. R1 = 1 kΩ und R2 = 10 kΩ gewählt. Die resultierende Frequenz liegt damit im Bereich hunderter Hz bis einiger kHz:

$$\begin{aligned} T &= t_\text{high} + t_\text{low}\\[8pt] t_\text{high} &= \ln(2)\,(R_1 + R_2)\,C_1 \\[8pt] t_\text{low} &= \ln(2)\,R_2\,C_1 \\[8pt] T&= \ln(2)\,(R_1 + 2R_2)\,C_1 \\[8pt] f &= \frac{1}{T} =\frac{1}{\ln(2)\,(R_1 +2R_2)\,C_1} \end{aligned} $$

Daraus folgt für die Kapazität: $$ C = \frac{1}{\ln(2)\,(R_1 + 2R_2)\,f} \approx \frac{1{,}44}{(R_1 + 2R_2)\,f}. $$

Die Genauigkeit hängt u. a. ab von:

• den Toleranzen der Widerstände,
• der Signalform (steile Flanken!),
• stabilen Messzeiten (Timer-Genauigkeit),
• und dem Schwingungsverhalten der Schaltung.

// ------------------------------------
// Kapazitätsmessung mit pulseIn()
// ------------------------------------
const int signalPin = 7;
unsigned long highDuration = 0;
unsigned long lowDuration  = 0;
float frequency = 0;

void setup() {
  Serial.begin(9600);
  pinMode(signalPin, INPUT);
  Serial.println("🔍 Frequenztest mit pulseIn()");
}

void loop() {
  highDuration = pulseIn(signalPin, HIGH, 1000000);
  lowDuration  = pulseIn(signalPin, LOW,  1000000);

  if (highDuration > 0 && lowDuration > 0) {
    float periodMicroSec = highDuration + lowDuration;
    frequency = 1e6 / periodMicroSec;

    Serial.print("HIGH: "); Serial.print(highDuration);
    Serial.print(" µs, LOW: "); Serial.print(lowDuration);
    Serial.print(" µs → f: "); Serial.print(frequency, 2);
    Serial.println(" Hz");
  } else {
    Serial.println("⚠️ Kein stabiler Puls erkannt");
  }

  delay(500);
}

Für höhere Stabilität und größere Frequenzen bietet sich eine Interrupt-basierte Messung an:

// -------------------------------------------------
// Kapazitätsmessgerät – Interrupt-Version
// PHOF Aug 2025
// Signal an Pin 2 (INT0), Mittelung über N Werte
// -------------------------------------------------
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27,20,4);

volatile unsigned long lastMicros = 0;
volatile unsigned long interval = 0;

const int N = 20;
float freqSum = 0;
int freqCount = 0;

void setup() {
  Serial.begin(9600);

  lcd.init();
  lcd.backlight();
  lcd.setCursor(0,0);  lcd.print("Kapazitaets-Messung");

  pinMode(2, INPUT);
  attachInterrupt(digitalPinToInterrupt(2), risingEdge, RISING);

  Serial.println("📡 Frequenzmessung gestartet");
}

void loop() {
  noInterrupts();
  unsigned long currentInterval = interval;
  interrupts();

  if (currentInterval > 0) {
    float freq = 1e6 / currentInterval;  // µs → Hz
    freqSum += freq;
    freqCount++;

    if (freqCount >= N) {
	 float avgFreq = freqSum / freqCount;
	 float capacitance = 1.44 / (21000.0 * avgFreq);  // F
	 float capacitance_nF = capacitance * 1e9;        // nF

	 Serial.print("⏱ f: ");
	 Serial.print(avgFreq, 2);
	 Serial.print(" Hz → C: ");
	 Serial.print(capacitance_nF, 2);
	 Serial.println(" nF");

	 lcd.setCursor(2,1);
	 lcd.print("F: "); lcd.print(avgFreq, 1); lcd.print(" Hz   ");

	 lcd.setCursor(2,2);
	 lcd.print("C: "); lcd.print(capacitance_nF, 2); lcd.print(" nF   ");

	 // Reset
	 freqSum = 0;
	 freqCount = 0;
    }
  }
  delay(50);
}

void risingEdge() {
  unsigned long now = micros();
  if (now - lastMicros > 100) {      // Entprellung / Min-Intervall
    interval = now - lastMicros;
    lastMicros = now;
  }
}

Messwerte

Vergleich von Oszilloskop/Funktionsgenerator und Arduino-Messung:

Für den praktischen Einsatz genügt ein Arduino Nano, ein 2-zeiliges LCD oder kleines OLED sowie der NE555-Oszillator – alles kompakt in einem Gehäuse.