Effizientes Widerstandssortieren für Arduino-Nano-Projekte: Eine einfache, zeitsparende Methode

Komponenten und Zubehör

• Arduino Nano R3 × 1
• Widerstand 100 Ω × 1
• Widerstand 1 kΩ × 1
• Widerstand 10 kΩ × 1
• Widerstand 100 kΩ × 1
• Widerstand 1 MΩ × 1
• ElectroPeak 0,96″ OLED 64×128 Display-Modul (I²C) × 1
• Jumper-Kabel (diverse) × 1

Benötigte Werkzeuge und Maschinen

• 3D-Drucker (beliebig)
• Lötkolben (beliebig)

Apps und Online-Dienste

• Arduino IDE

Über dieses Projekt

Kennst du das? Nach jedem abgeschlossenen Projekt liegt ein unsortierter Haufen Widerstände auf dem Arbeitstisch. Die Farbcodes zu entziffern ist mühsam, und selbst das Multimeter einzusetzen, scheint zu viel Aufwand. Hier kommt die Lösung: das ultimative „Faule-Ohmmeter“!

Alles, was du brauchst, sind ein paar Widerstände mit bekannten Werten, ein Arduino und ein Display (ich verwendete ein I²C-OLED). Das Prinzip basiert auf dem Spannungsteiler: Ein bekannter Referenzwiderstand (R_ref) und der unbekannte Widerstand (R_x) bilden einen Spannungsteiler. Der Arduino misst die Spannung am Mittelabgriff und berechnet R_x.

Das Problem mit der Genauigkeit

Je größer der Unterschied zwischen R_ref und R_x, desto ungenauer wird die Messung. Um dies zu umgehen, verwendet das Gerät fünf Referenzwiderstände (100 Ω, 1 kΩ, 10 kΩ, 100 kΩ, 1 MΩ). Der Arduino wählt automatisch den am besten passenden Referenzwiderstand aus, indem er die gemessene Spannung prüft: Liegt der ADC-Wert zwischen 350 und 800 (entspricht ca. 1,7–3,9 V bei 5 V Betriebsspannung), ist der Teiler optimal ausbalanciert.

Schaltplan

Die fünf Referenzwiderstände werden über digitale Pins (D2–D6) nacheinander an den Analogeingang A0 geschaltet. Nur der jeweils aktive Pin wird auf OUTPUT HIGH gesetzt; alle anderen werden auf INPUT (hochohmig) geschaltet, um die Messung nicht zu verfälschen. Das OLED-Display wird über I²C (A4=SDA, A5=SCL) angebunden.

Funktionsweise der Software

1. Im loop() wird beginnend mit dem größten Referenzwiderstand (1 MΩ) der ADC-Wert an A0 eingelesen.
2. Liegt der Wert außerhalb des „guten“ Bereichs (350–800), wird der nächste kleinere Referenzwiderstand aktiviert.
3. Sobald ein passender Referenzwiderstand gefunden ist, wird die unbekannte Widerstandswert nach der Spannungsteilerformel berechnet:

   Vout = 5 * (raw / 1024)
   Rx   = (Rref * Vout) / (5 - Vout)

4. Der errechnete Wert wird auf gängige E-Reihen-Werte gerundet (z. B. auf 10 Ω, 100 Ω, 1 kΩ …) und auf dem OLED angezeigt.

Hinweis #1: In jedem if-Zweig muss der PinMode der zuvor genutzten Pins wieder auf INPUT gesetzt werden, da ein auf OUTPUT LOW gesetzter Pin niederohmig wäre und die Messung verfälschen würde.

Hinweis #2: Du kannst beliebig viele weitere Referenzwiderstände an freie digitale Pins anschließen und die Abfragekette im Code erweitern.

Aufbau und Gehäuse

Der Prototyp entstand auf dem Steckbrett. Für den dauerhaften Einsatz wurde ein 3D-gedrucktes Gehäuse entworfen, in dem die Referenzwiderstände platzsparend verlötet sind. Zwei kleine Öffnungen dienen als Prüffassung für die unsortierten Widerstände. Einfach einstecken, Wert ablesen, sortieren – fertig!

Code

Der vollständige Sketch nutzt die Adafruit-SSD1306-Bibliothek für das OLED. Zwei Bitmap-Grafiken (Logo und Dekor) sind im Code als PROGMEM-Arrays hinterlegt. Die Rundungslogik wurde nachträglich korrigiert, um Fehler bei Werten um 5 kΩ zu vermeiden. Optional kann ein 5-kΩ-Referenzwiderstand hinzugefügt werden.

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
#define OLED_RESET     4

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);

// ... Bitmap-Arrays myLOGO[] und myBitmap[] ...

int R1 = 100, R2 = 1000, R3 = 10000;
long R4 = 100000, R5 = 1000000;
long Rn;
int D2 = 2, D3 = 3, D4 = 4, D5 = 5, D6 = 6;
float raw = 0, Vout = 0, Ru = 0;
int Analogohm = A0;

void setup() {
  Serial.begin(9600);
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306 allocation failed"));
    for (;;);
  }
  display.clearDisplay();
  display.drawBitmap(0, 0, myLOGO, 128, 64, WHITE);
  display.display();
  delay(2000);
}

void loop() {
  // Referenzwiderstände nacheinander prüfen, beginnend mit 1 MΩ
  pinMode(D2, OUTPUT); pinMode(D3, INPUT); pinMode(D4, INPUT); pinMode(D5, INPUT); pinMode(D6, INPUT);
  digitalWrite(D2, HIGH);
  raw = analogRead(Analogohm);
  Rn = R5;
  if (raw < 350 || raw > 800) {
    digitalWrite(D2, LOW); pinMode(D2, INPUT);
    pinMode(D3, OUTPUT); digitalWrite(D3, HIGH);
    raw = analogRead(Analogohm); Rn = R4;
    if (raw < 350 || raw > 800) {
      digitalWrite(D3, LOW); pinMode(D3, INPUT);
      pinMode(D4, OUTPUT); digitalWrite(D4, HIGH);
      raw = analogRead(Analogohm); Rn = R3;
      if (raw < 350 || raw > 800) {
        digitalWrite(D4, LOW); pinMode(D4, INPUT);
        pinMode(D5, OUTPUT); digitalWrite(D5, HIGH);
        raw = analogRead(Analogohm); Rn = R2;
        if (raw < 350 || raw > 800) {
          digitalWrite(D5, LOW); pinMode(D5, INPUT);
          pinMode(D6, OUTPUT); digitalWrite(D6, HIGH);
          raw = analogRead(Analogohm); Rn = R1;
        }
      }
    }
  }

  Vout = 5.0 * (raw / 1024.0);
  Ru = (Rn * Vout) / (5.0 - Vout);

  // Runden auf gängige E-Reihen-Schritte
  if (Ru < 100)       Ru = 10 * round(Ru / 10);
  else if (Ru < 1000) Ru = 100 * round(Ru / 100);
  else if (Ru < 10000) Ru = 1000 * round(Ru / 1000);
  else if (Ru < 100000) Ru = 10000 * round(Ru / 10000);
  else if (Ru < 1000000) Ru = 100000 * round(Ru / 100000);
  else                Ru = 1000000 * round(Ru / 1000000);

  showResistance(Ru);
  delay(1000);
}

void showResistance(long value) {
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(WHITE);
  display.setCursor(0, 0);
  display.println(F("Hey there,"));
  display.println(F("the Resistor value is"));
  display.setCursor(20, 25);
  display.setTextSize(2);
  display.print(value);
  display.print(F(" Ohm"));
  display.drawBitmap(0, 0, myBitmap, 128, 64, WHITE);
  display.display();
  delay(2000);
}

Fazit

Mit wenigen Bauteilen und etwas Code lässt sich ein praktisches Sortiergerät bauen, das den Arbeitstisch aufräumt und dabei noch Spaß macht. Der 3D-gedruckte Kasten macht es zu einem handlichen Werkzeug für jeden Elektronikbastler.