Linienfolger-Simulator: Roboter im Browser abstimmen

Steuerung

Nutze die Streckenvoreinstellungen als Basis oder pausiere den Lauf und zeichne direkt auf den Kurs. Die Robotergeschwindigkeit steuert, wie weit das Chassis pro Update vorrückt. Sensoranzahl und -abstand ändern das Sichtfeld. Die Regler P, I und D ändern die Lenkantwort; Schritt rechnet im Pausezustand ein deterministisches Update weiter.

Beginne mit mittlerer Geschwindigkeit, fünf Sensoren und Standardverstärkungen. Ändere eine Variable nach der anderen und vergleiche Fehler, Rundenzeit und Spurtreue-Kennzahlen.

Theorie

Der Sensorbalken tastet Reflexion vor dem Roboter ab. Jeder aktive Sensor trägt seine vorzeichenbehaftete Position zu einem gewichteten Mittel bei. Die Balkenmitte ist Fehler null; Messwerte links oder rechts der Mitte ergeben negativen oder positiven Fehler.

Der Regler kombiniert drei Anteile:

$$u(t) = K_p e(t) + K_i \int e(t)dt + K_d \frac{de(t)}{dt}$$

Die Korrektur $u(t)$ beschleunigt ein Rad und bremst das andere. P-Regelung reagiert auf den aktuellen Offset, I-Regelung korrigiert bleibende Verzerrung, D-Regelung dämpft schnelle Änderungen.

Algorithmus

1. Jeden Sensor in festem Intervall abtasten.
2. Gewichtete Linienposition berechnen und um die Mitte normieren.
3. Letzte beobachtete Linienrichtung weiter nutzen, wenn alle Sensoren die Spur verlieren.
4. Integral- und Differenzialanteil mit demselben festen Zeitschritt aktualisieren.
5. Korrektur klemmen, linken und rechten Motorbefehl berechnen und Roboterpose integrieren.

Stimme die Proportionalverstärkung ab, bis der Roboter sanften Kurven folgt, füge D-Verstärkung hinzu, bis das Pendeln sich setzt, und nur so viel Integralverstärkung, dass ein wiederholbarer Offset verschwindet.

Quellcode

Der Browser-Simulator und ein Mikrocontroller nutzen dieselbe Regelform. Eine kompakte Schleife im Arduino-Stil sieht so aus:

float integral = 0.0f;
float previousError = 0.0f;

void controlStep(float dt) {
  float error = readWeightedLinePosition();
  integral = constrain(integral + error * dt, -2.0f, 2.0f);
  float derivative = (error - previousError) / dt;
  float correction = kp * error + ki * integral + kd * derivative;

  setMotorSpeeds(baseSpeed - correction, baseSpeed + correction);
  previousError = error;
}

Halte das echte Regelintervall stabil. Variable Verzögerung ändert Differenzial- und Integralanteil, auch wenn die Verstärkungen gleich bleiben.

Annahmen und Unterschiede zur Hardware

Dies ist ein Lehrmodell, kein Hardware-Nachbau. Die Strecke ist eine flache, kontrastreiche Binärmaske ohne Umgebungslichtschwankung — der Sensorbalken sieht perfektes Schwarz und Weiß. Auf echtem Klebeband ändern Raumlicht, Oberflächenglanz und Sensorhöhe die Messwerte, du musst kalibrieren wie in den Verdrahtungshinweisen. Das Timing ist ideal: Der Regler läuft in festem Intervall ohne delay()-Jitter, während eine physische Arduino-Schleife mit anderer Arbeit schwankt und dieser Jitter die PID-Antwort formt. Das Chassis ist kinematisch: Räder rutschen nie, Motoren antworten instantan, die Batterie bricht nie ein. Behandle hier gefundene Verstärkungen als nahen Startpunkt und stimme am echten Roboter nach Kalibrierung neu ab.

Schaltplan

Verbinde die Sensorausgänge mit analogfähigen Eingängen, führe Masse zwischen allen Modulen gemeinsam und treibe Motoren über eine H-Brücke statt aus Controller-Pins.

Prüfe die Motorversorgungs-Bemessung und füge lokale Stützkondensatoren nahe Controller und Treiber hinzu. Führe Motorstrom nie durch den Logikregler eines Entwicklungsboards.

Geführte Experimente

Jedes isoliert eine Variable — genau das ist auf echter Hardware schwer, wo sich alles zugleich ändert.

1. Kritische Verstärkung finden, dann halbieren

Setze Integral- und Differenzialverstärkung auf null und erhöhe die Proportionalverstärkung, bis der Roboter auf Geraden gleichmäßig pendelt — mit konstanter statt wachsender oder schrumpfender Amplitude. Halbiere diesen Wert.

Du hast nun einen Start-Kp aus Messung statt Schätzung, und er wird nah dran sein. Füge von dort D hinzu, bis das Pendeln ausdämpft.

2. Beweisen, dass Verstärkungen geschwindigkeitsabhängig sind

Stimme den Roboter ab, bis er bei niedriger Grundgeschwindigkeit sauber folgt. Erhöhe nun die Geschwindigkeit um die Hälfte und fahre dieselben Verstärkungen unverändert.

Er wird pendeln, Kurven schneiden oder die Linie verlieren. Am Regler hat sich nichts geändert — doch dieselbe Lenkkorrektur erzeugt nun mehr Kursänderung pro Streckeneinheit, die wirksame Verstärkung stieg also mit der Geschwindigkeit. Jede Abstimmung ist eine Abstimmung bei einer Geschwindigkeit — darum bremst ein Wettbewerbsroboter für Kurven statt überall mit einer Verstärkung zu fahren.

3. Beobachten, was die Sensoranzahl ermöglicht

Fahre dieselbe Strecke mit denselben Verstärkungen mit drei, fünf und acht Sensoren.

Das interessante Ergebnis: Mehr Sensoren heben die Decke statt den Boden zu verbessern. Bei niedrigem Tempo genügen drei Sensoren. Die Extraauflösung zahlt sich erst bei den Geschwindigkeiten aus, wo das grobe Fehlersignal begrenzt.

4. Absichtlich in scharfer Kurve scheitern

Erhöhe die Geschwindigkeit, bis der Roboter in der engsten Kurve die Linie verliert. Beobachte, was er dann tut. Überlege dann, was der echte Roboter tun sollte: Geradeaus weiterzufahren ist die schlechteste Option, denn die Linie bog weg.

Das ist die Begründung, bei Spurverlust den letzten Fehler zu halten statt zu nullen — null heißt „mittig“ und kommandiert Vollgas geradeaus. Den letzten Fehler zu halten lässt den Roboter weiterdrehen, wie er schon drehte — dorthin, wo die Linie hinlief.

Was du beobachten solltest

Umsetzung auf Hardware

Hier gefundene Verstärkungen übertragen sich als naher Startpunkt, das Abstimmverfahren vollständig. Stimme auf eigenem Klebeband neu ab — und erwarte die größte Einzelverbesserung auf Hardware nicht von den Verstärkungen, sondern von der Schleifenrate, denn ein erster Aufbau läuft oft mit 20–50 Hz und erreicht mehrere Hundert schlicht durch Entfernen blockierender Aufrufe. Der komplette Bau steht in Linienfolger-Roboter bauen.