Widerstand messen ohne Multimeter – Arduino macht’s möglich

Mit einem einfachen Mikrocontroller wie dem Arduino lässt sich ein überraschend präzises Messgerät für elektrische Widerstände bauen – ganz ohne klassisches Multimeter. Die Grundlage dafür bildet eine einfache Spannungsteilerschaltung, bestehend aus einem bekannten, festen Referenzwiderstand und einem variablen, unbekannten Widerstand, den du messen möchtest. Diese beiden Widerstände werden in Serie geschaltet und mit 5 V Versorgungsspannung vom Mikrocontroller betrieben.

Über einen analogen Eingang wird die Spannung zwischen den beiden Widerständen erfasst. Mithilfe einer einfachen Formel lässt sich daraus der unbekannte Widerstand berechnen. Wichtig ist dabei: Die vom Mikrocontroller ausgegebenen 5 V sind nicht immer exakt, sondern können je nach Modell und Qualität leicht schwanken. Um genaue Messergebnisse zu erzielen, solltest du daher die tatsächliche Spannung mit einem Multimeter nachmessen und diesen Wert im Programm verwenden.

In diesem Beitrag zeige ich dir, wie du diese Schaltung aufbaust, wie die Berechnung funktioniert und wie du das Ganze mit wenigen Zeilen Code zum Leben erweckst.

💡 Hinweis: Die Idee zu dieser Schaltung stammt aus einem kurzen TikTok-Video, das mir beim Durchscrollen aufgefallen ist. Die dort gezeigte Umsetzung hat mich inspiriert, das Prinzip genauer zu analysieren, selbst nachzubauen und hier im Blog ausführlich zu beschreiben – inklusive Hintergrundwissen, Schaltplan und Arduino-Code.

Inhaltsverzeichnis

• Wie funktioniert eine Spannungsteilerschaltung?
• Aufbau der Schaltung auf dem Breadboard
  • Hinweis zum Piezo Buzzer
• Schaltung
• Referenzwiderstand und Versorgungsspannung vorher genau messen
• Quellcode zum messen von Widerständen am Arduino
• Fazit

Wie funktioniert eine Spannungsteilerschaltung?

Die Spannungsteilerschaltung ist eine der grundlegendsten und nützlichsten Schaltungen in der Elektronik. Sie besteht aus zwei Widerständen, die in Serie geschaltet werden, also hintereinander. An den Anfang der Kette wird eine Spannungsquelle (in unserem Fall 5 V vom Mikrocontroller) angeschlossen, ans Ende die Masse (GND). Zwischen den beiden Widerständen entsteht eine Teilspannung, die sich einfach messen lässt – genau hier liegt der Trick.

Das Prinzip:
Der Gesamtstrom durch beide Widerstände ist gleich. Die Spannung teilt sich jedoch verhältnismäßig zur Größe der Widerstände auf. Die Spannung am Verbindungspunkt der beiden Widerstände hängt also davon ab, wie groß der untere Widerstand im Verhältnis zum oberen ist.

• Vin​: Eingangsspannung (z. B. 5 V)
• Vout​: Spannung am Verbindungspunkt
• R1​: oberer Widerstand (Referenzwiderstand)
• R2​: unterer Widerstand (unbekannter Widerstand)

Wenn du also den Wert von R1 kennst und Vout misst, kannst du durch einfaches Umstellen der Formel den unbekannten Widerstand R2 berechnen. Genau dieses Prinzip nutzen wir in unserem kleinen Arduino-Projekt, um Widerstände zu bestimmen – ganz ohne klassisches Messgerät.

Aufbau der Schaltung auf dem Breadboard

Die Schaltung baue ich wie immer auf einem Breadboard auf, dieses hat den Vorteil das man auf diesem recht einfach die Bauteile aufstecken und mit entsprechenden Kabeln verbinden kann.

Zusätzlich verwende ich:

• einen Arduino UNO R3*,
  • ein passendes USB-Datenkabel*
• ein Acryl Board* inkl. 400 Pin Breadboard*,
• diverse Breadboardkabel*, 10cm, männlich – männlich,
• zwei Breadboardkabel* (schwarz & rot), 20cm, männlich – männlich,
• einen Referenzwiderstand von 10kOhm* (mit 1% Toleranz),
• diverse unbekannte Widerstände zum prüfen
• ein Piezo Buzzer*
• ein 0,96″ OLED-Display* mit I2C Schnittstelle

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Hinweis zum Piezo Buzzer

Es gibt bei den Piezo Buzzer unterschiede, bei einigen ist es egal wie diese angeschlossen werden bei anderen musst du auf die korrekte Polarität achten. Dazu reicht jedoch schon ein Blick auf das Gehäuse, hier ist ein Plus-Symbol am Pin gedruckt.

Schaltung

Bevor wir zur Programmierung kommen, werfen wir einen Blick auf den elektrischen Aufbau. Die gesamte Schaltung basiert auf einem einfachen Spannungsteiler, bestehend aus einem bekannten Referenzwiderstand und dem zu messenden Widerstand. Ergänzt wird das Ganze durch ein OLED-Display, auf dem der ermittelte Wert direkt angezeigt wird, sowie einem Piezo-Buzzer, der bei nahezu 0 Ohm ein akustisches Signal ausgibt.

Im folgenden Schaltplan siehst du, wie alle Komponenten miteinander verbunden werden und an welchen Pins sie am Arduino UNO angeschlossen sind.

Referenzwiderstand und Versorgungsspannung vorher genau messen

Damit die Berechnung des unbekannten Widerstands möglichst präzise erfolgt, ist es wichtig, zwei Werte vorab genau zu bestimmen:

1. Der Referenzwiderstand (R1)
   Verwende am besten einen Widerstand mit geringer Toleranz (1 % oder besser) und miss seinen tatsächlichen Wert mit einem Multimeter. Ein nomineller 10 kΩ-Widerstand kann in der Praxis z. B. 9,95 kΩ oder 10,1 kΩ betragen. Diesen exakten Wert trägst du dann im Programmcode ein.
2. Die Versorgungsspannung (Vin)
   Auch wenn der Arduino UNO mit 5 V arbeitet, liegt die tatsächliche Spannung oft etwas darunter oder darüber – abhängig von USB-Spannung, Board-Qualität und Last. Miss die Spannung am 5V-Pin des Arduino mit einem Multimeter und verwende diesen gemessenen Wert im Code, um die Spannung Vin korrekt zu setzen.

Nur wenn diese beiden Werte möglichst exakt sind, ergibt die Widerstandsberechnung aus dem Spannungsteiler auch ein realistisches und zuverlässiges Messergebnis.

Quellcode zum messen von Widerständen am Arduino

Wenn der Referenzwiderstand und die Versorgungsspannung von 5V am Arduino gemessen wurde, können wir uns dem Quellcode widmen. Dieser ist recht einfach und gliedert sich in 3 Abschnitte:

• auslesen des Widerstandes,
• umrechnen zu Ohm, kOhm, MOhm,
• ertönen des Piezo Buzzers bei 0 Ohm (Durchgang)

Für die Ansteuerung des Displays verwende ich die Adafruit SSD1306 Bibliothek welche du über den Bibliotheksverwalter der Arduino IDE installieren kannst.

Die Schriftart auf dem OLED-Display kannst du im Programmcode ganz einfach anpassen. Die Adafruit GFX-Library bietet dir dafür eine Auswahl an eingebetteten Fonts, die du über #include und setFont() aktivieren kannst. Je nach Displaygröße und gewünschtem Layout kannst du so eine besser lesbare oder kompaktere Darstellung erreichen.

Eine Übersicht aller verfügbaren Schriftarten findest du im offiziellen Adafruit-Beitrag unter:
🔗 https://learn.adafruit.com/adafruit-gfx-graphics-library/using-fonts

Dort findest du auch Beispiele zur Integration und Vorschauen der jeweiligen Schriftarten.

/***************************************************************
 * Autor:       Stefan Draeger
 * Webseite:    https://draeger-it.blog
 * Projekt:     DIY Widerstandsmessgerät mit OLED-Anzeige
 * Beschreibung:
 * Dieses Projekt misst unbekannte Widerstände mithilfe einer 
 * einfachen Spannungsteilerschaltung und einem Arduino UNO.
 * Der Referenzwiderstand R1 ist exakt gemessen (hier: 9,95 kOhm),
 * ebenso die Versorgungsspannung (hier: 4,94 V).
 * Der Wert des unbekannten Widerstands wird am analogen Pin A0 
 * erfasst, aus 10 Messungen gemittelt und auf einem OLED-Display 
 * angezeigt. Zusätzlich ertönt bei nahezu 0 Ohm ein kurzer Piepton,
 * womit sich die Schaltung auch als Durchgangsprüfer eignet.
 ***************************************************************/

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Fonts/FreeMono9pt7b.h>

// Displaykonfiguration
#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET -1
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// Pin-Definitionen
#define piezoBuzzer 7     // Piezo-Buzzer an D7
#define analogPin A0      // Analogeingang zur Spannungserfassung

#define debug false       // Debug-Modus für serielle Ausgabe

// Kalibrierte Werte für genaue Messung
const float Vin = 4.94;        // Exakt gemessene Versorgungsspannung (V)
const float R1 = 9950.0;       // Exakt gemessener Referenzwiderstand (Ohm)

float R2 = -1;                 // Zwischenspeicher für gemessenen Widerstand

void setup() {
  Serial.begin(9600);          // Serielle Schnittstelle starten

  display.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS); // OLED initialisieren
  display.display();           // Begrüßungsbild anzeigen
  delay(2000);                 // Kurze Pause vor Messung
}

void loop() {
  float newR2 = calculateR2(); // Neuen Messwert berechnen

  if (newR2 != R2) {           // Nur bei geänderten Werten aktualisieren
    R2 = newR2;

    String value = "-undefined-";

    // Einheitenerkennung und Umrechnung
    if (R2 < 1000.0) {
      value = String(R2, 1) + " Ohm";
    } else if (R2 < 1000000.0) {
      value = String(R2 / 1000.0, 2) + " kOhm";
    } else if (R2 < 10000000.0) {
      value = String(R2 / 1000000.0, 3) + " MOhm";
    } else {
      value = String(0, 3) + " Ohm"; // Fehlerfall
    }

    if (R2 == 0) {
      tone(piezoBuzzer, 600, 25);  // Piezo piept bei 0 Ohm
    }

    displayNewValue(value); // Neuen Wert am Display anzeigen
  }
}

// Funktion zur Anzeige auf OLED
void displayNewValue(String value) {
  display.clearDisplay();
  display.setFont(&FreeMono9pt7b);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(0, 25);
  display.println(value);
  display.display();
}

// Funktion zur Widerstandsmessung mit Mittelwertbildung
float calculateR2() {
  const int numReadings = 10;  // Anzahl der Messwiederholungen
  float sum = 0;

  for (int i = 0; i < numReadings; i++) {
    int raw = analogRead(analogPin);                   // Rohwert vom ADC
    float Vout = raw * (Vin / 1023.0);                  // Spannung berechnen
    float R2 = (Vout * R1) / (Vin - Vout);              // Spannungsteiler-Formel
    sum += R2;
    delay(5); // kurze Pause zur Glättung
  }

  float avgR2 = sum / numReadings;                     // Durchschnitt berechnen

  if (debug) {
    Serial.print("Gemittelter Widerstand: ");
    Serial.println(avgR2);
  }

  return avgR2;
}

Fazit

Das Messen von Widerständen mit dem Arduino ist dank einer einfachen Spannungsteilerschaltung unkompliziert und liefert erstaunlich präzise Ergebnisse – vorausgesetzt, man kennt den Referenzwiderstand und die Versorgungsspannung genau. Mit etwas zusätzlichem Code und einem OLED-Display lässt sich daraus sogar ein praktisches kleines Messgerät für das heimische Labor oder die Bastelkiste bauen.

Trotzdem sollte man realistisch bleiben: Ein klassisches, geprüftes Multimeter bietet deutlich mehr Komfort – insbesondere durch die Möglichkeit, auch Spannungen (Gleich- und Wechselspannung) sowie Stromstärken zu messen. Solche Geräte sind bereits ab rund 15 € erhältlich und damit eine sinnvolle Ergänzung zu jedem DIY-Messprojekt.

Dieses Arduino-Projekt zeigt jedoch schön, wie leicht sich mit einfachen Mitteln funktionale Tools realisieren lassen – und ganz nebenbei lernt man eine Menge über Spannungsteiler, Analogmessung und Code-Strukturierung.