PID-Regler mit BASCOM (in Arbeit)


Bei den verwendeten Robotern wird ein PID-Regler verwendet. PID steht hier für P (Proportionalregler) I (Integralregler) D (Differentialregler). Vorbereitet ist die Software um alle drei Regler nutzen zu können, aktuell werden aber lediglich der P und D Regler genutzt.

Bevor wir in die Programmierung einsteigen, vorab nochmals eine kurze Einführung die die Regelungstechnik. Weitere Informationen findet man unter RN-Wissen – Regelungstechnik

P-Regler
Der proportional wirkende Regler ändert das Fehlersignal proportional (also im Verhältnis) zum Eingangssignal durch die Multiplikation einer Fehlerkonstanten. Im Beispiel wird das Eingangssignal mit 1.5 multipliziert -> also um das anderthalbfache verstärkt

kp = 15
kp_err = sensor * kp
kp_err = kp_err / 10

I-Regler
Diese Regler integriert (also addiert die laufenden Fehlersignale) auf und multiplizierte diese mit einer Fehlerkonstanten. Im Beispiel wird das Eingangssignal mit 1.1 multipliziert -> also leicht verstärkt und aufsummiert.

ki = 11
ki_err = sensor * ki
ki_err = ki_err / 10
ki_sum = ki_sum + ki_err

D-Regler
Der differential wirkende Regler vergleicht das aktuelle Signal mit dem letzten Fehlersignal. Aus der Differenz beider berechnet er das neue Fehlersignal. Sinn dieses Reglers ist es ein gewisse Vorausschau zu erhalten.
Im Beispiel wird das Eingangssignal mit 1.5 multipliziert und mit dem letzten Fehlersignal differenziert.

kd = 15
kd_err = sensor * kd
kd_err = kd_err / 10
kd_err = kd_old - kd_err

Kommen wir nun dazu, wie dieser Regler-Algorithmus für die Roboter implementiert wurde. Als Eingangssignal werden die Sensorwerte der Liniensensor-Leiste verwendet. Ob nun 7 oder 15 Sensoren verwendet werden ist für den PID-Regler irrelevant. Das angewendete Verfahren ist grundsätzlich gleich.

Gehen wir von einer 7x-IR Sensorleiste aus, ist der erste Schritt, die Sensoren in einen normierten Wertebereich zu transformieren. Hierbei nutzen wir die Möglichkeit Listen (Arrays) in BASCOM zu verwenden. Basis ist der mittlere Sensor. Dieser Sensor steht genau auf der Linie, wenn der Roboter mittig auf der Linie positioniert wurde. Ziel des Reglers ist es, den Roboter immer auf diesen Sensor zu positionieren.

Mit anderen Worten: Wenn der mittlere Sensor auf der Linie steht, soll der PID-Regler kein Fehlersignal zurückliefern (also 0).
Je weiter der Roboter von der Mitte entfernt ist (also die äußeren Sensoren auf schwarz stehen) umso größer muss das Fehlersignal werden.

Lösung:

Sensor_liste(1) = 275 ' linker Sensor
Sensor_liste(2) = 200
Sensor_liste(3) = 75
Sensor_liste(4) = 0 ' Mitte
Sensor_liste(5) = -75
Sensor_liste(6) = -200
Sensor_liste(7) = -275 ' rechter Sensor

Die Frage, warum die rechten Sensoren negative Werte haben, wird gleich erklärt.

Selbst ohne PID-Regler könnte nun ein einfacher Linienalgorithmus angewendet werden. Die linken Sensoren subtrahieren ihre Werte von der Geschwindigkeit des linken Motors und addieren ihren Wert zur Geschwindigkeit des rechten Motors. Gleiches gilt für die rechten Sensoren. Sie subtrahieren ihren Wert vom linken Motor und addieren zum rechten Motor.

Was passiert hier?

power_links = 700 - sensor_liste(sensor)
power_rechts = 700 + sensor_liste(sensor)

Stellen wir uns vor der Roboter steht mit Sensor (1) auf der Linie

power_links = 700 - 275 ' power_links = 475
power_rechts = 700 + 275 ' power_rechts = 975

Demnach fährt der Roboter eine Linkskurve, da der linke Motor langsamer dreht als der Rechte. Ist auch richtig, da der Roboter letztendlich rechts von der Linie steht!

Stellen wir uns vor der Roboter steht mit dem Sensor (7) auf der Linie

power_links = 700 - (-275) ' power_links = 975
power_rechts = 700 + (-275) ' power_rechts = 475

Demnach fährt der Roboter eine Rechts, da der linke Motor schneller dreht als der Rechte. Ist auch richtig, da der Roboter letztendlich links von der Linie steht!

voila, der Linienalgorithmus ist geboren 🙂

Die Verwendung des PID-Reglers nimmt nun die Sensorsignale aus der Liste (z.B. 275) und berechnet nun aus diesen den P-Anteil und den D-Anteil. Beide Anteile werden auf das Sensorsignal aufaddiert und es entsteht ein neues Fehlersignal. Dieses wird anschließend für die Berechnung der neuen Motorgeschwindigkeit verwendet.


pid = PID_REGLER(sensor_liste(sensor)
power_links = 700 - pid
power_rechts = 700 + pid


function PID_REGLER (signal as integer) as integer
local pid as integer
kp = 20
ki = 0
kd = 15
' Proportional-Regler

kp_err = signal * kp
kp_err = kp_err / 10

' Integral-Regler

ki_err = signal * ki
ki_err = ki_err / 10
ki_sum = ki_sum + ki_err

' Differential-Regler

kd_err = signal * kd
kd_err = kd_err / 10
kd_err = kd_old - kd_err
kd_old = kd_err

' Fehlersignale aufaddieren

pid = kp_err + ki_sum
pid = pid + kd_err

' und zurückgeben

PID_Regler = pid
end function

Advertisements
  1. Hinterlasse einen Kommentar

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden /  Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden /  Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden /  Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden /  Ändern )

w

Verbinde mit %s

%d Bloggern gefällt das: