IR Reflectance Sensor Array

Was es ist

Ein IR-Reflexions-Sensorarray ist ein Streifen kleiner Infrarot­sensoren in einer Reihe, auf den Boden gerichtet. Jeder Sensor paart eine Infrarot-LED, die Licht nach unten strahlt, mit einem Fototransistor, der misst, wie viel dieses Lichts zurückprallt. Richte es auf eine dunkle Linie auf hellem Boden und die Linie reflektiert weniger – also liest der Sensor über der Linie anders als die über dem Boden. Die ganze Reihe zu lesen und du weißt nicht nur, ob du auf der Linie bist, sondern wo die Linie unter dem Roboter sitzt.

Es ist das Auge fast jedes Linienfolge­roboters, und der Grund, warum der Linienfolger so ein gutes Erstprojekt ist: Die Sensorik ist billig, anschaulich und sofort sichtbar.

Wie es funktioniert

Jeder Kanal ist ein Sender-Empfänger-Paar. Die IR-LED sendet unsichtbares ~940-nm-Licht; der Fototransistor leitet mehr, je mehr Licht zurückkehrt. Eine weiße oder helle Fläche reflektiert stark (hohe Rückkehr); eine schwarze Linie schluckt das IR (niedrige Rückkehr). Zwei Ausgangsarten existieren:

• Analog – jeder Kanal meldet einen kontinuierlichen Wert proportional zur Reflexion. Das ist reicher: Du kannst rechnen, wo zwischen zwei Sensoren die Linie liegt, und bekommst ein glattes Fehlersignal für einen PID-Regler.
• Digital – ein Bord­komparator meldet ein simples Linie/keine-Linie pro Kanal. Leichter zu lesen, aber gröber.

Um aus dem Array ein Lenksignal zu machen, rechnest du einen gewichteten Mittelwert, welche Sensoren die Linie sehen. Wandert die Linie unter die linken Sensoren, verschiebt sich der Mittelwert links, und dieser Versatz wird der Fehler, den deine Regelschleife korrigiert.

Wann man es verwendet

Nutze ein Reflexions­array, wann immer ein Roboter einem kontrastreichen Pfad folgen muss – einer schwarzen Linie auf Weiß oder weißem Klebeband auf dunklem Boden. Mehr Kanäle geben feinere Positions­auflösung und lassen den Roboter Kurven und Lücken gnädiger handhaben; fünf reichen zum Lernen, acht sind komfortabel für schnellere oder kurvigere Strecken.

Es ist das falsche Werkzeug zum Erkennen von Objekten, Distanz oder allem abseits der Bodenebene – das ist der Job eines Ultraschall- oder Time-of-Flight-Sensors.

Kalibrierung und Fallstricke

• Immer kalibrieren. Umgebungs­licht, Oberfläche und Fahrhöhe verschieben alle die Messwerte. Vor einer Fahrt das Array über Linie und Boden schwenken und Min/Max pro Kanal festhalten, dann Messwerte dazwischen skalieren. Das zu überspringen ist der Nummer-eins-Grund, warum ein Linienfolger auf einem Tisch geht und auf einem anderen scheitert.
• Höhe zählt. Reflexions­sensoren haben einen engen Sweet Spot (wenige Millimeter). Das Array zu hoch montiert und der Kontrast kollabiert.
• Umgebungs-IR ist Rauschen. Sonnenlicht und manche Beleuchtung fluten die Detektoren mit Infrarot. Sensoren abschirmen oder drinnen fahren für konsistentes Verhalten, und das Signal filtern – siehe Sensor­rauschen zähmen.
• Oberflächen­finish lügt. Glänzendes Schwarz kann im falschen Winkel wie Weiß reflektieren; mattes Klebeband auf mattem Boden ist die verlässliche Kombination.

An einen Arduino verdrahten

Ein analoges Array braucht einen ADC-Pin pro Kanal, weshalb ein 8-Kanal-Array und ein Uno (sechs Analogeingänge) eine ungünstige Paarung sind – die acht eines Nano (A0–A7) passen exakt.

Dieser LEDON-Pin lohnt sich zu verdrahten, obwohl ihn die meisten Projekte ignorieren. Die Sender eines 8-Kanal-Arrays können zusammen 100–200 mA ziehen, dauerhaft, was an einem kleinen Akku ein spürbarer Anteil des Budgets ist – und er erlaubt Umgebungs­licht­subtraktion, unten.

Kalibrierung: der Code, der entscheidet, ob es geht

Das ist nicht optional und keine Verfeinerung. Ein unkalibriertes Array ist der häufigste Grund, warum ein Linienfolger auf dem Küchentisch geht und beim Wettbewerb scheitert.

const int N = 8;
const int PIN[N] = {A0, A1, A2, A3, A4, A5, A6, A7};
int lo[N], hi[N];

void calibrate() {
  for (int i = 0; i < N; i++) { lo[i] = 1023; hi[i] = 0; }

  // Sweep the array across the line and the floor for ~3 seconds.
  unsigned long start = millis();
  while (millis() - start < 3000) {
    for (int i = 0; i < N; i++) {
      int v = analogRead(PIN[i]);
      if (v < lo[i]) lo[i] = v;
      if (v > hi[i]) hi[i] = v;
    }
  }
}

// 0 = floor, 1000 = line, per channel, normalised against this run's own extremes.
int normalised(int i) {
  int span = hi[i] - lo[i];
  if (span < 50) return 0;                       // this channel never saw contrast
  return constrain(map(analogRead(PIN[i]), lo[i], hi[i], 0, 1000), 0, 1000);
}

Beachte den span < 50-Wächter. Ein Kanal ohne Kontrast während der Kalibrierung – weil der Schwenk ihn verpasste oder sein Sender tot ist –, würde sonst aus winzigem Rauschen enorme normierte Werte erzeugen, und der Roboter schwenkte zu einem Sensor, der ihm nichts sagt.

Aus acht Messwerten eine Lenkzahl

Der gewichtete Mittelwert ist der ganze Trick, und er erzeugt eine kontinuierliche Position statt eines diskreten „Sensor 3 sieht sie“:

// Returns position in the same units as the weights: 0..7000 for an 8-channel array,
// or -1 if the line is not visible at all.
long linePosition() {
  long weighted = 0, total = 0;
  for (int i = 0; i < N; i++) {
    int v = normalised(i);
    if (v > 100) {                    // ignore channels that are clearly on floor
      weighted += (long)v * i * 1000;
      total    += v;
    }
  }
  if (total == 0) return -1;          // line lost
  return weighted / total;
}

// Error for the control loop: 0 when centred.
long error() {
  long pos = linePosition();
  if (pos < 0) return LAST_ERROR;     // hold the last known direction, do not zero it
  return pos - 3500;                  // centre of an 8-channel array
}

Zwei Entwurfs­entscheidungen darin zählen mehr als die Arithmetik:

Kanäle unter einer Schwelle zu ignorieren hindert Bodenrauschen daran, den Mittelwert zu ziehen. Ohne das ziehen acht Kanäle mit je kleinem Nicht-null-Wert die Schätzung zur Mitte, egal wo die Linie ist.

Den letzten Fehler zurückzugeben, wenn die Linie verloren ist – statt null –, lässt einen Roboter sich aus einer scharfen Ecke erholen. Null heißt „perfekt mittig“, also fährt ein Roboter, der bei Linienverlust nullt, geradeaus mit Vollgas weiter, weg von der gerade verlorenen Linie. Den letzten Fehler zu halten heißt, er dreht weiter, wie er schon drehte, wohin die Linie ging.

Montagehöhe, und warum sie alles entscheidet

Reflexions­sensoren haben einen engen Sweet Spot. Das Signal fällt in beide Richtungen schnell ab: Zu hoch und die Rückkehr ist schwach, zu tief und der Kegel des Senders hat sich nicht genug gespreizt, um zu beleuchten, was der Detektor sieht.

Zwei praktische Folgen. Montiere es starr – ein Array an flexiblem Halter ändert Höhe, wie der Roboter beschleunigt, was die Messwerte ändert, was die Regelschleife als sich bewegende Linie liest. Und montiere es waagerecht, denn ein gekipptes Array gibt jedem Kanal eine andere wirksame Höhe und damit eine andere Kalibrierung, was sich als Roboter zeigt, der in eine Richtung gut und in die andere schlecht spurt.

Es vor den Rädern zu montieren zählt auch: Je weiter vorn, desto früher sieht der Roboter eine Ecke und desto mehr Vorlaufzeit hat der Regler. Zu weit vorn und die Geometrie verstärkt den Fehler zur Schwingung.

Umgebungs­licht schlagen

Sonnenlicht enthält viel 940-nm-Infrarot, und es kommt am Detektor an und sieht exakt wie eine Reflexion aus. Ein Roboter, der drinnen geht und nahe einem Fenster scheitert, sieht fast immer das.

Wenn sich die Sender deines Arrays schalten lassen, ist die Lösung vollständig und kostet zwei Messungen:

int ambientSubtracted(int i) {
  digitalWrite(LEDON, LOW);   delayMicroseconds(200);
  int dark = analogRead(PIN[i]);      // ambient only
  digitalWrite(LEDON, HIGH);  delayMicroseconds(200);
  int lit  = analogRead(PIN[i]);      // ambient + our own emitter
  return lit - dark;                  // just our emitter
}

Alles Konstante in der Umgebung kürzt sich exakt. Es verdoppelt die Abtastzeit, was an einem schnellen Linienfolger echte Kosten sind – aber es verwandelt einen unzuverlässigen Sensor in einen verlässlichen, und es ist die Technik, die kommerzielle Arrays nutzen.

Andernfalls: Das Array mit einer Schürze abschirmen, sodass es nur den Boden direkt darunter sieht.

Fehlerbehebung

Ein Array wählen

Analog schlägt digital für alles mit Regelschleife. Der Komparator eines digitalen Arrays gibt dir Linie/keine-Linie pro Kanal, was die Position in eine Handvoll diskreter Werte quantisiert und ruhiges proportionales Lenken unmöglich macht. Analog gibt ein kontinuierliches Fehlersignal, was ein PID-Regler braucht.

Der Kanalabstand zählt ebenso wie die Zahl: Das Array soll breiter als die Linie sein, genug, dass immer mindestens ein Sensor an jeder Kante auf dem Boden ist, aber nicht so breit, dass die Linie zwischen zwei Sensoren ungesehen sitzen kann. Für Standard-19-mm-Isolierband passen 8 mm Abstand gut.

Für einen Linien­labyrinth­löser gibt es eine Extra­anforderung: Das Array muss breit genug sein, um eine Kreuzung zu sehen. Ein Roboter erkennt ein Linksabbiegen daran, dass die äußersten linken Sensoren dunkel wurden, während die Mitte noch auf der Linie ist – was unmöglich ist, wenn das Array kaum breiter als das Band ist.