Drehzahlmesser mit Arduino bauen: RPM messen mit IR-Sensor, Interrupts & OLED-Anzeige

Wie man eine Drehzahl überhaupt misst

Das Prinzip ist immer dasselbe: An der drehenden Welle sitzt eine Markierung, ein Sensor erkennt sie einmal pro Umdrehung, und der Mikrocontroller zählt die Impulse oder misst den Abstand zwischen zweien. Der Unterschied liegt nur im Sensor:

Für Maker-Projekte gewinnt der FC-51: kostet fast nichts, liefert ein sauberes Digitalsignal (kein Analogwert, den du selbst schwellen musst) und funktioniert bis in den Bereich von einigen tausend Umdrehungen pro Minute.

Das brauchst du

Dazu ein Streifen weißes Papier oder Klebeband für die Markierung – und schwarzer Edding für den Rest der Welle.

1Verkabelung

Die Markierung anbringen

Der FC-51 erkennt Reflexion. Er meldet LOW, wenn viel Licht zurückkommt (helle Fläche nah), und HIGH bei dunkel oder weit weg. Praktisch heißt das:

• Welle oder Radscheibe mit schwarzem Edding einfärben – mattes Schwarz reflektiert kaum.
• Einen schmalen Streifen weißes Klebeband längs aufkleben. Ein Streifen = 1 Impuls pro Umdrehung.
• Sensor auf 5 bis 15 mm Abstand bringen, senkrecht auf die Fläche.
• Am blauen Poti drehen, bis die Modul-LED beim langsamen Vorbeidrehen sauber ein- und ausschaltet.

2Erste Version: Impulse zählen

Der einfachste funktionierende Drehzahlmesser zählt Impulse in einem festen Zeitfenster. Robust, leicht zu verstehen, gut für mittlere und hohe Drehzahlen:

#define SENSOR_PIN   2
#define LED_PIN      8

const uint8_t  IMPULSE_PRO_UMDREHUNG = 1;
const uint16_t MESSFENSTER_MS        = 1000;

// volatile: wird in der ISR geaendert, der Compiler darf nichts wegoptimieren
volatile uint32_t impulsZaehler = 0;

unsigned long letzteAuswertung = 0;
float rpm = 0;

// Interrupt-Routine: so kurz wie irgend moeglich
void impulsErkannt() {
  impulsZaehler++;
}

void setup() {
  Serial.begin(115200);
  pinMode(SENSOR_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);

  // FALLING: nur die abfallende Flanke zaehlt -> ein Impuls pro Streifen
  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), impulsErkannt, FALLING);

  Serial.println(F("Drehzahlmesser bereit"));
}

void loop() {
  if (millis() - letzteAuswertung >= MESSFENSTER_MS) {
    letzteAuswertung = millis();

    // Zaehler atomar auslesen und zuruecksetzen:
    // ohne noInterrupts() koennte genau dazwischen ein Impuls verlorengehen
    noInterrupts();
    uint32_t impulse = impulsZaehler;
    impulsZaehler = 0;
    interrupts();

    rpm = (impulse / (float)IMPULSE_PRO_UMDREHUNG)
          * (60000.0 / MESSFENSTER_MS);

    Serial.print(F("Impulse: "));
    Serial.print(impulse);
    Serial.print(F("   RPM: "));
    Serial.println(rpm, 1);

    digitalWrite(LED_PIN, impulse > 0 ? HIGH : LOW);
  }
}

3Zweite Version: Periodenmessung für langsame Wellen

Bei 40 U/min und einem Impuls pro Umdrehung zählt das Fenster-Verfahren pro Sekunde entweder 0 oder 1 Impuls – die Anzeige springt zwischen 0 und 60 U/min hin und her. Die Lösung: nicht Impulse pro Zeit zählen, sondern die Zeit zwischen zwei Impulsen messen. Das gibt selbst bei einer Umdrehung pro Minute noch einen brauchbaren Wert.

#define SENSOR_PIN   2

const uint8_t  IMPULSE_PRO_UMDREHUNG = 1;
const uint32_t ENTPRELL_US           = 2000;    // 2 ms Mindestabstand
const uint32_t TIMEOUT_MS            = 3000;    // danach gilt: steht still

volatile uint32_t letzteFlankeUs = 0;
volatile uint32_t periodeUs      = 0;
volatile bool     neuerWert      = false;

void impulsErkannt() {
  uint32_t jetzt = micros();
  uint32_t delta = jetzt - letzteFlankeUs;   // ueberlaufsicher

  // Prellen und Stoerimpulse ausfiltern
  if (delta < ENTPRELL_US) return;

  periodeUs      = delta;
  letzteFlankeUs = jetzt;
  neuerWert      = true;
}

float rpm = 0;
unsigned long letzteAnzeige = 0;

void setup() {
  Serial.begin(115200);
  pinMode(SENSOR_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), impulsErkannt, FALLING);
}

void loop() {
  // Neuen Messwert uebernehmen
  if (neuerWert) {
    noInterrupts();
    uint32_t p = periodeUs;
    neuerWert = false;
    interrupts();

    if (p > 0) {
      // 60 Sekunden = 60.000.000 Mikrosekunden
      float roh = 60000000.0 / ((float)p * IMPULSE_PRO_UMDREHUNG);

      // Exponentiell gleitender Mittelwert glaettet das Zittern
      rpm = (rpm == 0) ? roh : (rpm * 0.8 + roh * 0.2);
    }
  }

  // Stillstand erkennen: seit TIMEOUT_MS kein Impuls mehr
  noInterrupts();
  uint32_t alterMs = (micros() - letzteFlankeUs) / 1000UL;
  interrupts();

  if (alterMs > TIMEOUT_MS) rpm = 0;

  if (millis() - letzteAnzeige >= 250) {
    letzteAnzeige = millis();
    Serial.print(F("RPM: "));
    Serial.println(rpm, 1);
  }
}

4Anzeige auf dem OLED

Zahl allein reicht nicht – ein Balken zeigt auf einen Blick, ob der Motor schneller oder langsamer wird:

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

Adafruit_SSD1306 display(128, 64, &Wire, -1);

const uint16_t RPM_MAX = 300;    // Skalenendwert fuer den Balken

// Ringpuffer fuer den Verlauf: 64 Werte, ein Pixel pro Wert
uint8_t verlauf[64];
uint8_t verlaufIndex = 0;

void displayStarten() {
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("OLED nicht gefunden"));
    while (true) { delay(1000); }
  }
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.display();
}

void verlaufSchreiben(float wert) {
  uint16_t begrenzt = (uint16_t) constrain(wert, 0, RPM_MAX);
  verlauf[verlaufIndex] = map(begrenzt, 0, RPM_MAX, 0, 20);
  verlaufIndex = (verlaufIndex + 1) % 64;
}

void zeigeDrehzahl(float wert, uint32_t umdrehungenGesamt) {
  display.clearDisplay();

  // Grosse Zahl
  display.setTextSize(3);
  display.setCursor(0, 0);
  display.print((int) round(wert));

  display.setTextSize(1);
  display.setCursor(92, 14);
  display.print(F("U/min"));

  // Balken 0 bis RPM_MAX
  uint8_t breite = map((uint16_t) constrain(wert, 0, RPM_MAX),
                       0, RPM_MAX, 0, 126);
  display.drawRect(0, 28, 128, 10, SSD1306_WHITE);
  display.fillRect(1, 29, breite, 8, SSD1306_WHITE);

  // Verlaufskurve der letzten 64 Messungen
  for (uint8_t x = 0; x < 64; x++) {
    uint8_t i = (verlaufIndex + x) % 64;
    uint8_t h = verlauf[i];
    if (h > 0) display.drawFastVLine(x * 2, 62 - h, h, SSD1306_WHITE);
  }

  // Gesamtzahl der Umdrehungen rechts unten
  display.setCursor(74, 42);
  display.print(F("Ges: "));
  display.print(umdrehungenGesamt);

  display.display();
}

5Vom Messen zum Regeln: konstante Drehzahl halten

Jetzt wird es interessant. Wenn du die Drehzahl kennst, kannst du sie auch halten – unabhängig von Last und Batteriespannung. Ein einfacher PI-Regler reicht dafür völlig:

#define MOTOR_PWM_PIN  9

float sollRpm = 120.0;
float istRpm  = 0.0;

// Reglerparameter - experimentell ermitteln
float kP = 0.35;      // Proportionalanteil: reagiert auf die aktuelle Abweichung
float kI = 0.08;      // Integralanteil: beseitigt die bleibende Restabweichung

float integral = 0.0;
uint8_t stellwert = 0;

unsigned long letzteRegelung = 0;
const uint16_t REGEL_INTERVALL_MS = 100;

void regele() {
  if (millis() - letzteRegelung < REGEL_INTERVALL_MS) return;

  float dt = (millis() - letzteRegelung) / 1000.0;
  letzteRegelung = millis();

  float fehler = sollRpm - istRpm;

  integral += fehler * dt;

  // Anti-Windup: Integral begrenzen, sonst laeuft er beim Blockieren voll
  integral = constrain(integral, -400.0, 400.0);

  float ausgang = kP * fehler + kI * integral;
  ausgang = constrain(ausgang, 0, 255);

  stellwert = (uint8_t) ausgang;
  analogWrite(MOTOR_PWM_PIN, stellwert);
}

void setup() {
  Serial.begin(115200);
  pinMode(MOTOR_PWM_PIN, OUTPUT);
  analogWrite(MOTOR_PWM_PIN, 0);

  pinMode(SENSOR_PIN, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(SENSOR_PIN), impulsErkannt, FALLING);

  letzteRegelung = millis();
}

void loop() {
  istRpm = aktuelleDrehzahl();   // aus Schritt 2 oder 3
  regele();

  static unsigned long letzteAusgabe = 0;
  if (millis() - letzteAusgabe >= 500) {
    letzteAusgabe = millis();
    Serial.print(F("Soll: "));  Serial.print(sollRpm, 0);
    Serial.print(F("  Ist: ")); Serial.print(istRpm, 0);
    Serial.print(F("  PWM: ")); Serial.println(stellwert);
  }
}

6Hohe Drehzahlen: der 130er Motor als Stresstest

Ein 130 Micro DC Motor dreht bis 20.000 U/min. Bei einem Impuls pro Umdrehung sind das 333 Impulse pro Sekunde – alle 3 ms eine ISR. Das schafft der ATmega locker. Kritisch wird es erst bei mehreren Markierungen oder wenn du zusätzlich mit Reflexionen kämpfst.

// Fuer hohe Drehzahlen: Fenster kuerzen und ISR minimal halten
const uint16_t MESSFENSTER_MS = 200;    // 5 Aktualisierungen pro Sekunde

volatile uint16_t impulse16 = 0;        // 16 Bit reicht: max 65535 pro Fenster

void impulsErkannt() {
  impulse16++;                          // ein einziger Befehl in der ISR
}

float messeSchnell() {
  static unsigned long letzte = 0;
  static float wert = 0;

  if (millis() - letzte >= MESSFENSTER_MS) {
    letzte = millis();

    noInterrupts();
    uint16_t n = impulse16;
    impulse16 = 0;
    interrupts();

    float roh = (n / (float)IMPULSE_PRO_UMDREHUNG)
                * (60000.0 / MESSFENSTER_MS);

    // Bei hohen Drehzahlen staerker glaetten, sonst tanzt die Anzeige
    wert = wert * 0.7 + roh * 0.3;
  }
  return wert;
}

// Plausibilitaetspruefung: unrealistische Spruenge verwerfen
float pruefePlausibel(float neu, float alt) {
  const float MAX_SPRUNG = 3000.0;   // U/min pro Messintervall

  if (alt > 0 && fabs(neu - alt) > MAX_SPRUNG) {
    return alt;                      // Ausreisser ignorieren
  }
  return neu;
}

Troubleshooting

Praxistipps

• Erst die LED, dann der Code. Die kleine LED auf dem FC-51-Modul zeigt dir beim Justieren sofort, ob der Sensor die Markierung sieht. Wer das überspringt, sucht den Fehler danach stundenlang in der Software.
• Markierung so groß wie nötig, so klein wie möglich. Ein 5 mm breiter Streifen wird bei hoher Drehzahl zu einem sehr kurzen Impuls. Bei schnellen Motoren lieber breiter kleben, bei langsamen schmaler für präzisere Flanken.
• Immer gegen eine zweite Quelle prüfen. Filme die Welle mit dem Handy in Zeitlupe und zähle die Umdrehungen über fünf Sekunden. Stimmt das mit deiner Anzeige überein, kannst du dem Aufbau vertrauen.
• Gesamtzähler mitlaufen lassen. Ein uint32_t mit allen bisherigen Umdrehungen macht aus dem Tacho nebenbei einen Betriebsstundenzähler – nützlich für Wartungsintervalle bei Pumpen und Lüftern.
• ISR so kurz wie irgend möglich. Ein Inkrement, eine Zeitmessung – mehr nicht. Keine Serial.print, kein delay(), keine Display-Ausgabe. Alles andere gehört in die loop().
• Messwerte protokollieren. Mit einem Micro-SD-Modul schreibst du die Drehzahl über Stunden mit und siehst Lastspitzen, die du live nie bemerkt hättest – siehe Arduino Datenlogger mit Micro-SD-Karte.
• Auf dem ESP32 wird der Tacho drahtlos. Derselbe Aufbau schickt seine Werte per WebSocket ins Browser-Diagramm – dann brauchst du am Motor gar kein Display mehr.