deutsch     english     français     Drucken

 

5.3 STEUERN UND REGELN

 

 

EINFÜHRUNG

 

Im Zusammenhang mit Maschinen, zu denen auch die Roboter gehören, stellt sich oft das Problem, sie so zu steuern, dass eine bestimmte Messgrösse einen vorgegebenen Wert, den Sollwert, möglichst gut einhält. Beispielsweise soll im  Auto der Tempomat eine vorgegebene Geschwindigkeit auch dann einhalten, wenn das Auto eine Steigung oder ein Gefälle durchfährt. Dazu muss ein Regelungssystem mit einem Sensor die aktuelle Geschwindigkeit, den Istwert, bestimmen und mit einem Stellglied die Leistung des Motors entsprechend anpassen, also sozusagen das Gaspedal bedienen.

Weitere Beispiele von technischen Regelungssystemen:

  • Temperatur eines Kühlschranks einhalten (Thermostatregelung)
  • Ein Flugzeug auf einem bestimmten Kurs halten (Autopilot)
  • Füllstand eines Flüssigkeitsreservoirs einhalten (z.B. WC-Spülung)

Auch viele menschliche Tätigkeiten können als Regelungsprozess aufgefasst werden. Beispiele:

  • Auto lenken, dass es auf der Strasse bleibt
  • Soviel arbeiten, dass man gerade knapp durch die Promotion kommt
  • Beim Stehen auf einem Fuss das Gleichgewicht behalten

PROGRAMMIERKONZEPTE: Regelungssystem, Istwert, Sollwert, Messfehler

 

 

SELF-DRIVING CAR

 

Das Autofahren ist ein komplexer Regelungsprozess mit vielen Eingangssignalen, die vom Fahrer optisch, aber auch taktil (Kräfte am Körper) erfasst werden. Die geistige Verarbeitung dieser Signale führt zu seinem Verhalten (Drehung des Steuerrades, Drücken der Pedale, usw.).
In der Zukunft werden Fahrzeuge den Weg sogar in einer komplexen verkehrstechnischen Situation ohne einen menschlichen Fahrer finden. Mehrere  Forschungsgruppen auf der ganzen Welt arbeiten an diesem Problem und vielleicht wirst du dich einmal an dieser interessanten Forschung beteiligen. In einer stark vereinfachten Situation kannst du hier deine Fähigkeiten bereits auf eine Probe stellen.

 

 

Deine Aufgabe ist es, den Roboter, der mit einem Fahrwerk und einem Lichtsensor ausgerüstet ist und  damit die Helligkeit der Unterlage misst, auf einer grünen Strasse entlang zu führen, die von einem gelben und schwarzen Gebiet umgeben ist. Der Sensor meldet auf der grünen Unterlage einen mittleren, auf der gelben eine grossen und auf der schwarzen einen kleinen Lichtwert. Es ist die Aufgabe des Regelungssystems, aus den gemessenen Lichtwerten ein Steuersignal für die Motoren zu erstellen, damit der Roboter möglichst gut der Strasse entlang fährt.

 

Schematisch kann man diesen Prozess in einem Regelungskreis aufzeichnen. Der Lichtsensor misst den aktuellen Lichtwert (Istwert) und liefert ihn an den Regler. Dieser vergleicht ihn mit dem gewünschten Wert (Sollwert) auf der grünen Strasse. Aus der Differenz errechnet der Regler gemäss einem von dir zu erfindenden Regleralgorithmus die Steuergrösse für das Fahrwerk, d.h. die zwei Motoren werden entsprechend geschaltet.


Regelungskreis

Wie du siehst, handelt es sich tatsächlich schematisch um einen "Kreis" vom Fahrzeugsensor, zum Regelungssystem und wieder zurück zu den Fahrzeugmotoren

Bevor du das Programm schreiben kannst, musst du noch die Lichtwerte kennen, die für die gelbe, grüne und schwarze Unterlage vom Sensor geliefert werden. Dazu schreibst du am besten ein kleines Testprogramm, das dir die gemessen Werte auf der Konsole bzw. auf dem Display ausschreibt. Im Realmodus brauchst du den Roboter nicht zu bewegen, sondern du kannst ihn einfach auf die entsprechende Unterlage stellen. Im Simulationsmodus fährst du über die entsprechend gefärbten Gebiete. (Dieser Prozess heisst Eichung.) Für den NXT verwendest du den NXT-LightSensor, für den EV3 kannst du den EV3-ColorSensor einsetzen.

 

from simrobot import *
#from nxtrobot import *
#from ev3robot import *

RobotContext.setStartPosition(250, 490)
RobotContext.useBackground("sprites/roadtest.gif")

robot = LegoRobot()
gear = Gear()
robot.addPart(gear)
ls = LightSensor(SensorPort.S3)
robot.addPart(ls)
ls.activate(True)
gear.forward()

while not robot.isEscapeHit():
    v = ls.getValue()
    print v
    Tools.delay(100)
robot.exit()
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

In deinem Programm verwendest du einen naheliegenden Regelalgorithmus: Ist der Istwert grösser als der Sollwert, so befindet sich das Fahrzeug im gelben Gebiet und du fährst eine Rechtskurve. Ist der Istwert hingegen kleiner als der Sollwert, so befindest es sich im schwarzen Gebiet und du fährst eine Linkskurve. Sonst fährst du geradeaus.

from simrobot import *
#from nxtrobot import *
#from ev3robot import *

RobotContext.setStartPosition(50, 490)
RobotContext.useBackground("sprites/road.gif")
  
robot = LegoRobot()
gear = Gear()
robot.addPart(gear)
ls = LightSensor(SensorPort.S3)
robot.addPart(ls)
ls.activate(True)
gear.forward()
nominal = 501

while not robot.isEscapeHit():
    actual = ls.getValue()
    if actual == nominal:
        gear.forward()
    elif actual < nominal:
        gear.leftArc(0.1)
    elif actual > nominal:
        gear.rightArc(0.1)

robot.exit()
Programmcode markieren (Ctrl+C kopieren, Ctrl+V einfügen)

 

 

MEMO

 

Im Simulationsmodus funktioniert die Regelung gut, im Realmodus aber gar nicht. Du merkst sicher warum: Die Messwerte des Sensors schwanken, auch wenn sich der Sensor über einem einheitlich gefärbten Gebiet befindet. Das ist ja auch zu erwarten, da die Helligkeit selbst auf der gleichen Unterlage auf Grund der Beleuchtungsunterschiede, aber auch wegen Messfehlern des Sensors, niemals exakt gleich bleibt. Finde selbst eine Lösung für dieses Problem!

Ein sensibler Parameter ist der Kurvenradius bei leftArc() bzw. rightArc(). In kleiner Wert führt zu kleineren "Ausreissern" von der Strasse weg, aber zu einem unruhigen, hin-und-her schwingenden Verhalten [mehr... Reglerschwingungen sind ein typisches Fehlverhalten von Regelungsprozessen
und können zum Versagen der Regelung führen (Instabilität)
], ein grosser Wert zur Beruhigung der Bewegung, aber zu einer weniger präzisen Führung auf der Strasse. Bestätige dies durch einige Versuche mit verändertem Kurvenradius.

 

 

AUFGABEN

 

1.

Fahre mit einem Lichtsensor entlang einer schwarz-grünen Kante. Im Simulationsmodus verwendest du den folgenden RobotContext:

RobotContext.useBackground("sprites/edge.gif")
RobotContext.setStartPosition(250, 490)

 

 


2.

Fahre mit zwei Lichtsensoren auf einem runden Pfad.

Im Simulationsmodus verwendest du den RobotContext:

RobotContext.useBackground("sprites/roundpath.gif")
RobotContext.setStartPosition(250, 250)
RobotContext.setStartDirection(-90)

Ändere die Startposition und die Startrichtung so, dass der Roboter bereits auf der Bahn startet.

 



3.

Fahre mit zwei Lichtsensoren auf einer Achterbahn. Im Simulationsmodus verwendest du das Hintergrundbild track.gif.

RobotContext.useBackground("sprites/track.gif")