FC-51 IR-Hindernissensor mit Arduino: Kollisionsschutz & Linienerkennung fuer Roboter

Wie ein IR-Reflexsensor funktioniert

Auf dem FC-51 sitzen zwei kleine "Augen": eine Infrarot-LED (sendet unsichtbares Licht) und ein Fototransistor (empfaengt es). Ist der Weg frei, verpufft das ausgesendete Licht im Raum – der Empfaenger sieht nichts. Kommt ein Objekt in Reichweite, wird das IR-Licht zurueck auf den Empfaenger reflektiert. Ein Komparator auf der Platine vergleicht das Signal mit einer Schwelle und schaltet den OUT-Pin auf LOW, sobald ein Hindernis erkannt wird.

Das Entscheidende: Der FC-51 misst keine Entfernung. Er liefert nur ein Ja/Nein – Hindernis da oder nicht. Die Ansprechschwelle stellst du mit einem Potentiometer auf der Platine ein. Fuer echte Abstandswerte in Zentimetern brauchst du einen HC-SR04 Ultraschallsensor oder einen VL53L0X Laser-Sensor.

• Reichweite: je nach Poti-Einstellung etwa 2–30 cm
• Ausgang: digital (HIGH = frei, LOW = Hindernis), kein Analogwert
• Betriebsspannung: 3,3–5 V – laeuft an Arduino wie an ESP32
• Onboard-LED: zeigt die Erkennung direkt an, praktisch beim Justieren

Das brauchst du

1Verkabelung & Reichweite einstellen

Der FC-51 hat drei Pins: VCC, GND und OUT. Wir haengen OUT an den Digitalpin D2.

Auf der Platine sitzt ein blaues Potentiometer. Damit stellst du die Reichweite ein: Halte ein Objekt (z. B. deine Hand) in den gewuenschten Abstand und drehe das Poti langsam, bis die zweite Onboard-LED gerade anspringt. Ziehst du die Hand weg, muss sie wieder ausgehen. So kalibrierst du die Schwelle rein per Auge – ganz ohne Code.

2Erstes Auslesen

Der Einstieg ist ein Dreizeiler: Pin als Eingang, Zustand lesen, ausgeben. Weil LOW ein Hindernis bedeutet, drehen wir die Abfrage entsprechend um:

#define IR_PIN 2

void setup() {
  pinMode(IR_PIN, INPUT);
  Serial.begin(115200);
  Serial.println("FC-51 bereit");
}

void loop() {
  int zustand = digitalRead(IR_PIN);

  if (zustand == LOW) {          // LOW = Hindernis
    Serial.println("Hindernis erkannt!");
  } else {
    Serial.println("frei");
  }
  delay(200);
}

Halte etwas vor den Sensor: Im Seriellen Monitor wechselt die Meldung sofort. Funktioniert das nicht, ist meistens das Poti zu unempfindlich eingestellt oder OUT haengt am falschen Pin.

3Sauber erkennen: entprellen & Alarm ausloesen

An der Grenze der eingestellten Reichweite "zittert" der Ausgang gerne zwischen HIGH und LOW. Fuer einen zuverlaessigen Alarm zaehlen wir deshalb nur einen stabilen Zustandswechsel – das Signal muss eine kurze Zeit konstant anliegen, bevor wir es glauben. Dazu schaltet der Sketch bei einem Hindernis eine LED an D8 ein:

#define IR_PIN  2
#define LED_PIN 8

int  letzterStabil = HIGH;         // zuletzt bestaetigter Zustand
int  letzterMesswert = HIGH;
unsigned long wechselZeit = 0;
const unsigned long entprellMs = 40;

void setup() {
  pinMode(IR_PIN, INPUT);
  pinMode(LED_PIN, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  int messwert = digitalRead(IR_PIN);

  // bei jeder Aenderung die Uhr neu starten
  if (messwert != letzterMesswert) {
    wechselZeit = millis();
    letzterMesswert = messwert;
  }

  // Zustand erst uebernehmen, wenn er lange genug stabil ist
  if (millis() - wechselZeit > entprellMs) {
    if (messwert != letzterStabil) {
      letzterStabil = messwert;

      if (letzterStabil == LOW) {
        digitalWrite(LED_PIN, HIGH);
        Serial.println("ALARM: Hindernis!");
      } else {
        digitalWrite(LED_PIN, LOW);
        Serial.println("wieder frei");
      }
    }
  }
}

4Praxisprojekt: Roboter weicht Hindernissen aus

Jetzt der Klassiker: ein kleiner Roboter, der eigenstaendig um Hindernisse herumfaehrt. Zwei FC-51 blicken schraeg nach vorne – einer links, einer rechts. Ist der Weg frei, faehrt der Roboter geradeaus. Meldet der linke Sensor ein Hindernis, weicht er nach rechts aus und umgekehrt. Melden beide etwas, faehrt er kurz zurueck und dreht.

Die beiden Motoren steuern wir hier vereinfacht ueber zwei Richtungspins pro Seite (in der Praxis meist ueber eine Treiberstufe, siehe Hinweis). Der Fokus liegt auf der Ausweich-Logik:

// FC-51 Ausweich-Roboter (Logik-Grundgeruest)
#define IR_LINKS  2
#define IR_RECHTS 3

// Motorpins (je Seite ein Vorwaerts-Pin, vereinfacht)
#define M_LINKS   5
#define M_RECHTS  6

void setup() {
  pinMode(IR_LINKS,  INPUT);
  pinMode(IR_RECHTS, INPUT);
  pinMode(M_LINKS,   OUTPUT);
  pinMode(M_RECHTS,  OUTPUT);
  Serial.begin(115200);
}

void vorwaerts()   { digitalWrite(M_LINKS, HIGH); digitalWrite(M_RECHTS, HIGH); }
void stopp()       { digitalWrite(M_LINKS, LOW);  digitalWrite(M_RECHTS, LOW);  }
void dreheRechts() { digitalWrite(M_LINKS, HIGH); digitalWrite(M_RECHTS, LOW);  }
void dreheLinks()  { digitalWrite(M_LINKS, LOW);  digitalWrite(M_RECHTS, HIGH); }

void loop() {
  bool hindernisLinks  = (digitalRead(IR_LINKS)  == LOW);
  bool hindernisRechts = (digitalRead(IR_RECHTS) == LOW);

  if (hindernisLinks && hindernisRechts) {
    // beide blockiert: kurz stoppen und wegdrehen
    stopp();
    delay(150);
    dreheRechts();
    delay(400);
  }
  else if (hindernisLinks) {
    dreheRechts();          // links blockiert -> nach rechts
  }
  else if (hindernisRechts) {
    dreheLinks();           // rechts blockiert -> nach links
  }
  else {
    vorwaerts();            // Weg frei
  }
}

5Weitere Einsaetze: Objektzaehler & Linienerkennung

Der FC-51 kann mehr als nur ausweichen. Zwei Ideen, die den gleichen Sensor nutzen:

Objektzaehler: Montierst du den Sensor an einer Foerderstrecke oder einem Durchgang, zaehlst du jedes vorbeiziehende Teil. Entscheidend ist, nur die Flanke zu zaehlen – also den Uebergang von "frei" zu "Hindernis", nicht jeden einzelnen LOW-Durchlauf:

#define IR_PIN 2

long zaehler = 0;
int  vorher = HIGH;

void setup() {
  pinMode(IR_PIN, INPUT);
  Serial.begin(115200);
}

void loop() {
  int jetzt = digitalRead(IR_PIN);

  // fallende Flanke: HIGH -> LOW = neues Objekt
  if (vorher == HIGH && jetzt == LOW) {
    zaehler++;
    Serial.print("Objekte gezaehlt: ");
    Serial.println(zaehler);
  }
  vorher = jetzt;
  delay(10);
}

Linienerkennung: Weil helle Flaechen IR-Licht gut reflektieren und schwarze es schlucken, erkennt der FC-51 den Kontrast zwischen weissem Boden und schwarzer Linie – die Basis fuer einen Linienfolge-Roboter. Fuer saubere Ergebnisse muss der Sensor allerdings dicht (wenige Millimeter) ueber dem Boden sitzen und das Poti feinfuehlig justiert sein. Spezielle Linienfolge-Module (TCRT5000) sind hier praeziser, fuer erste Experimente reicht der FC-51 aber gut.

Troubleshooting