Ja, genau das habe ich damit gemeint.
Gruß Waste
Druckbare Version
Ja, genau das habe ich damit gemeint.
Gruß Waste
WOW!
Da kann ich nur noch staunen. Ein beeindruckender und lehrreicher Thread. Dank an alle Mitwirkenden.
Waste,
ich habe Deinen Code leicht modifiziert, da Dein Programm bei mir keiner Linie folgte.
Folgende Aenderungen habe ich vorgenommen:
1.) die Variablen drest, xsum und xalt in MAIN, da diese Variablen sonst nicht initialisiert werden
2.) Linedata mit LED off zur Initialisierung von doff in MAIN, da bei mir die LED beim Ein- und Ausschalten in FollowLine zu traege ist und scheinbar immer an bleibt.
3.) Implementierung mit Lib Ver. 2.70
Das war's. Nun folgt mein Asuro brav der Linie und der PID-Regler ist viel sensibler als der einfache P-Regelkreis!
Ich habe noch eine Frage:
Ich verstehe die Logik beim abbremsen nicht.
Links von der Linie (rechts bremsen)ist der Code:
Links dagegenZitat:
speedRight = speed - y; // rechts abbremsen
Kannst Du mir das mal erklaeren. Besten Dank im voraus.Zitat:
speedLeft = speed + y; // links abbremsen
Hier ist der neue Code:
Code:/*******************************************************************************
*
* Description: Asuro Linienverfolgung mit PID-Regler
* Version 1: Korrektur auf beide Motoren verteilt
* Author: Waste 26.8.05
*
* Version 2: initialization of parameters in Main, measurement with LED off in Main
* Author: irobot22587 11.03.2007
*
*****************************************************************************/
#include "c:/WinAVR/avr/include/asuro.h" // ver 2.70
unsigned char speed;
int speedLeft,speedRight;
unsigned int lineData[2];
int x, xalt, don, doff, kp, kd, ki, yp, yd, yi, drest, y, y2, isum;
void FollowLine (void)
{
unsigned char leftDir = FWD, rightDir = FWD;
LineData(lineData); // Messung mit LED ON
don = (lineData[0] - lineData[1]);
x = don - doff; // Regelabweichung
isum += x;
if (isum > 16000) isum =16000; //Begrenzung um Überlauf zu vermeiden
if (isum < -16000) isum =-16000;
yi = isum/625 * ki; //I-Anteil berechnen
yd = (x - xalt)*kd; // D-Anteil berechnen und mit
yd += drest; // nicht berücksichtigtem Rest addieren
if (yd > 255) drest = yd - 255; // merke Rest
else if (yd < -255) drest = yd + 255;
else drest = 0;
if (isum > 15000) BackLED(OFF,ON); // nur zur Diagnostik
else if (isum < -15000) BackLED(ON,OFF);
else BackLED(OFF,OFF);
yp = x*kp; // P-Anteil berechnen
y = yp + yi + yd; // Gesamtkorrektur
y2 = y/2; // Aufteilung auf beide Motoren
xalt = x; // x merken
speedLeft = speedRight = speed;
MotorDir(FWD,FWD);
if ( y > 0) { // nach rechts
StatusLED(GREEN);
speedLeft = speed + y2; // links beschleunigen
if (speedLeft > 255) {
speedLeft = 255; // falls Begrenzung
y2 = speedLeft - speed; // dann Rest rechts berücksichtigen
}
y = y - y2;
speedRight = speed - y; // rechts abbremsen
if (speedRight < 0) {
speedRight = 0;
}
}
if ( y < 0) { // nach links
StatusLED(RED);
speedRight = speed - y2; // rechts beschleunigen !!!was speed - y2!!
if (speedRight > 255) {
speedRight = 255; // falls Begrenzung
y2 = speed - speedRight; // dann Rest links berücksichtigen !!was speed - speedRight!!
}
y = y - y2;
speedLeft = speed + y; // links abbremsen !! was speed + y!!!
if (speedLeft < 0) {
speedLeft = 0;
}
}
leftDir = rightDir = FWD;
if (speedLeft < 20) leftDir = BREAK; // richtig bremsen
if (speedRight < 20) rightDir = BREAK;
MotorDir(leftDir,rightDir);
MotorSpeed(abs(speedLeft),abs(speedRight));
}
int main(void)
{
unsigned char sw;
Init();
MotorDir(FWD,FWD);
StatusLED(GREEN);
speed = 150;
kp = 3; ki = 10; kd = 70; // Regler Parameter kd enthält bereits Division durch dt
drest=0;
isum=0;
xalt=0;
sw=0;
/*
sw = PollSwitch();
if (sw & 0x01)
{ki=20;}
if (sw & 0x02)
{speed = 200;}
if (sw & 0x04)
speed = 100;
if (sw & 0x08)
kd = 35;
if (sw & 0x10)
kd = 70;
if (sw & 0x20)
kd = 140;
*/
FrontLED(OFF);
Msleep(50);
LineData(lineData); // Messung mit LED OFF
doff = (lineData[0] - lineData[1]); // zur Kompensation des Umgebungslicht
FrontLED(ON);
Msleep(100);
speedLeft = speed;
speedRight = speed+25;
while(1){
FollowLine();
}
return 0;
}
Wenn y>0 ist, soll er rechts bremsen, also speedRight soll kleiner werden, das passt mit -y.Zitat:
Zitat von irobot_22587
Wenn y<0 ist, dann soll er links bremsen, speedLeft soll kleiner werden. Da y schon negativ ist, muss also +y da stehen.
Waste
Hallo an Alle, die zu diesem Artikel beigetragen haben...
Ich hätte allerdings nur noch eine Bitte:
Kann man das ganze Thema (ASURO mit PID-Regler) so kompensieren und kurz Beschreiben, dass auch Leute, die wenig Ahnung von Reglern haben einen Überblick bekommen???
(Besonders die Berechnung der P I und D Anteile mit den ganzen Variablen und Konstanten)
MfG
PS: Sozusagen "ASURO mit PID-Regler für Dummies"
hi,
vielleicht schaust du mal hier rein:
https://www.roboternetz.de/wissen/in...gelungstechnik
Hi,
Denke schon, dass man das kann ;-) also leg los, es hält dich bestimmt keiner davon ab das zu machen.Zitat:
Hallo an Alle, die zu diesem Artikel beigetragen haben...
Ich hätte allerdings nur noch eine Bitte:
Kann man das ganze Thema (ASURO mit PID-Regler) so kompensieren und kurz Beschreiben, dass auch Leute, die wenig Ahnung von Reglern haben einen Überblick bekommen???
(Besonders die Berechnung der P I und D Anteile mit den ganzen Variablen und Konstanten)
MfG
PS: Sozusagen "ASURO mit PID-Regler für Dummies"
mfg jeffrey
der PID Regler funktioniert wunderbar... hab noch nie eine so saubere Linienverfolgung hinbekommen. Werde mal ein Video demnächst reinstellen.
Mich interessiert das Thema auch, jedoch habe ich keinen Asuro zum Testen.
Kann daher nochmal jemand ein Video vom Asuro mit PID-Regler reinstellen? Die Videos hier aus dem Thread sind leider nicht mehr verfügbar.
Moin moin allerseits,
Toplles aber für mich ein etwas schwieriges Thema welches aber bald
auf mich zukommt. :-) Ich habe den Thread sowie das RN Wiki über
Regelstrecken gelesen, habe aber doch ein paar grundlegende Fragen.
Habe ich es richtig verstanden das ich die Sprungantwort möglichst
mit betriebsbereitem Bot ermitteln sollte damit halt die Verlußte und
die Massenträgheit gleich mit berücksichtigt werden?
Bei mir geht es weniger um Linienfolgen als um einen guten Gleichlauf
der Räder. Ich habe am Kollecktor der Scheibenwischermotoren kleine
Magnete befestigt welche mittels Hallsensor abgetastet werden und komme
bei vollast auf etwa 160 Hz. Diese Frequenzen möchte ich vergleichen
und die Differenz als Stellgröße verwenden.
Gleichzeitug/zusätzlich als Speedmeter und die Impulse selber als
Wegstreckenzähler....Für Kurvenfahrten stelle ich mir vor den einen
oder anderen oder Beide Motoren "gefälschte" Daten vorzulügen.
Haltet Ihr das vom Prinzip her (so) für durchfürbar?
Grüße Richard
Wieso möglichst. Nur - würde ich sagen. Man lässt ja die Motoren nicht alleine durch die Welt fahren.Zitat:
Zitat von Richard
Gleichlauf heisst doch: genaues Einhalten der Vorgaben. Damit ist es egal, welchen Zweck Du erreichen willst. Ich habe die Sprungantwort gemessen und daraus die Regelstrecke parameterisiert und rechne aus Zeitgründen alles integer. Läuft sehr schön (klar, eigene Erfolge sind IMMER gut)!Zitat:
Zitat von Richard
Ich gebe einfach die Daten vor, die ich haben will. Keine Ahnung was das mit dem "lügen" soll.Zitat:
Zitat von Richard
Moin moin Oberallgeier. :-)Zitat:
Zitat von oberallgeier
Mit "lügen" meinte ich die tatsächlichen IST Werte verändern,je nach
Bedarf etwas hinzuaddieren oder Abziehen um den Kurs zu beeinflussen,
ohne dabei die eigentliche Regelfunktion zu verlieren. Aber das kann jetzt
auch ein Denkfehler von mir sein, der soll Wert MUß ja nicht 0 sein wie
beim Linienfolgen.
Gruß Richard
Hallo Richard,
erst einmal schöne Weihnachten. Natürlich für alle Leser.
Ich bin auch fürs Lügen.
Sinn macht das Ganze ja auf alle Fälle dann, wenn eine Kurve z.B. so gefahren werden soll, so das ein Rad die doppelte Strecke gegenüber dem anderen fahren soll. Klar, dass ich dann bei den Tiks lüge und dem Regler etwas vom Pferd erzähle.
Der hier von waste entwickelte PID läßt sich auch für solche Dinge hervoragend nutzen und in einen Kurven-Regler (eine Gerade ist nur ein Sonderfall einer Kurve) umbauen.
Ist bei mir schon 'etwas' länger im Betrieb.
Hier mal meine vom Baron erzählte Lügengeschichte mitten im waste-Code:Der Regler nutzt dann die beiden Variablen LWert und RWert um 'seiner' Meinung nach geradeaus zu fahren. In sens.rad_tik [..] stehen bei mir die gemessenen Tiks. Und dann wird gelogen auf float komm raus.Code:case PID_ODOMETRIE:
if (links == 0 || rechts == 0)
use_regler = FALSE;
else
{
absLinks = abs (links);
absRechts = abs (rechts);
/* Odometrie-Zaehler so justieren, dass fuer eine Kurvenfahrt
die Tic-Anzahl auf beiden Seiten identisch aussehen.
Die Seite auf der weniger Tic's zu fahren sind wird auf die
hoehere Anzahl 'hochgerechnet'.
*/
if (absLinks < absRechts)
{
faktor = (float)absRechts / (float)absLinks;
LWert = sens.rad_tik [LINKS] * faktor;
RWert = sens.rad_tik [RECHTS];
}
else
{
faktor = (float)absLinks / (float)absRechts;
LWert = sens.rad_tik [LINKS];
RWert = sens.rad_tik [RECHTS] * faktor;
}
kp = g_kp;
ki = g_ki;
kd = g_kd;
}
break;
@oberallgeier
Lügen kann in der heutigen Zeit einfach hilfreich sein um die Kurve zu kratzen ;-). Außer man fährt AC-Schnitzer getunetes. Da wird natürlich rechtwinklig abgebogen ;-). (Schau bitte nicht auf die Uhrzeit. Ist Urlaub.)
Gruß und guten Rutsch ins Neue Jahr an alle.
Sternthaler
Halleluja,
ich verstehe die Sache mit dem "Lügen" trotzdem nicht. Nicht (nur) weil Weihnachten ist. Mein Regler für den Antrieb bei meinem Dottie sind ja zwei Regler, für jeden Motor, also für jedes Rad, ein eigener.
Die Funktionstüchtigkeit bzw. Adaptionsfähigkeit dieser Regler ist damit nachgewiesen, dass ich den identischen Algorithmus mit gleichen Parameterwerten habe für jeden einzelnen der zwei Antriebe, wobei die Antriebe deutlich unterschiedliche Zeitkonstanten (im Target gemessen) haben: 8 ms und 12 ms. Diese Unterschiede werden vom Algorithmus selbst sehr gut ausgeglichen - schaut euch die Dottie-Videos an: mein R2D03 läuft bei Geradeausfahrt auf 1 m mit weniger als +/- 1 mm Abweichung. Die Encoderauflösung ist etwa 1 Tic pro 0,1 mm Radumfang.
Mit den Hilfen aus dem RN habe ich meinen Regler aufgebaut. Meinen erprobten und aktuellen Code für den Motor 12 (1 und 2 sind zwei der vier Ausgänge am L293D) habe ich mit einigen meiner Überlegungen hier vorgestellt. UND wenn mein Dottie nun eine Kurve fahren soll, dann werden die Vorgaben entsprechend bereitgestellt - lügen ist das ja nun nicht. Da ich in der Regelroutine nur integer rechne (Zeitgründe - sie läuft ja im Interrupt), könnte es Sinn machen, den offset für das "schnellere" Rad beim Kurvenfahren erst floatingpoint zu berechnen und nach dieser Sollwertberechnung für das kurvenäussere Rad den "frac"-Anteil (also den Nachkommaanteil) für die nächste Berechnung zu konservieren. Dieser Überhang wird der nächsten Berechnung zugeschlagen, damit nicht durch Rundungsvorgänge die gewünschte Kurvenform leidet. Dieses Vorgehen steht noch auf meiner Vorhabenliste, über Auswirkung/Erfolg kann ich daher nicht berichten.
Lange Rede kurzer Sinn: lügt nicht. Ehrlich währt am längsten - und fährt am präzisesten *ggggggg*. Lügen langt aber sicher um die Kurve zu kratzen *gggggg*. Aber wer macht sowas schon.
@Sternthaler: der AC-Schnitzer muss leider ohne Regler auskommen - differentiallose Starrachse - und ich habe KEINEN Platz für nen Encoder. Aber das Teil wird ja auf AL (..AbstandsLimit..) geregelt, auch wenns nur ne sehr einfache Regelung ist ... warts mal ab, die Erlkönigphase ist eigentlich vorbei, ich muss aber noch eine saubere Kalibriermöglichkeit vor Fahrtantritt programmieren. Und . . . mein PC steht eigentlich in der Ecke - hier spricht nur der Not(fall)book.
Frohe Weihnachten
hi,
der asuro und der dottiregler unterscheiden sich ja schon.
man hat ja bei beiden eigentlich ein mimo system. bei dotti wird das mit 2 siso-regler geregelt, und beim asuro mit einem siso-regler. wenn ich das jetzt richtig erkannt habe.
bei dotti wird ür jdes rad eine solldrehzahl vorgegeben, die dann durch jeweils einen regler eingestellt wird.
beim asuro wird die drehzahl differenz ausgewertet und damit die motoren geregelt. mit dem vorlügen würde ich sagen ist gemeint, dass die tics verfälscht werde, sprich anzahl links *1,5, bedeutet, dass das rechte rad 2/3 längeren weg fährt wie das linke. ich persönlich halte aber diese variante nicht für so sinnvoll. dann liber den sollwert von der drehzahldifferenz ändern, also anstatt 0, irgendeinen anderen wert nehmen, dann kann auch weiterhin mit integers gerechnet werden.
so, ich hoff, verstanden zu haben, was die leute gmeinet haben, und ic hab net totalen schwachsinn verzapft.
noh weiterhin schöne feiertgae.
mfg jeffrey
So sehe ich das ja auch. Und deswegen und trotz meinem Erfolg bei meinem Miniprojekt - das ja auf wastes phantastischem Wicki-Artikel beruht - trau ich mich nicht an die Regelung des asuro heran. Annahme: wenn es besser ginge, hätte waste oder Sternthaler oder irgend ein anderer Guru das schon längst erledigt. Aber ich vermute, dass es beim asuro noch Möglichkeiten gibt. (.... die dann vielleicht DOCH auf mich warten ...... schrecklich!)Zitat:
Zitat von jeffrey
hallo ich habe ein Problem :D
ich könnte heulen mein Asuro macht einfach nicht das was er soll,
der Linie entlang fahren. Er ruckelt hin und her und erkennt auch manche dunkleren stellen doch nicht auf der linie er fährt immer ein kleines stück der linie entlang und dan biegt er ab. Manchmal fährt er am Rand des Papiers entlang aber meistens dreht er sich im Kreis. Ich weiß einfach nicht was ich noch machen soll ich habe schon so viele Programme ausprobiert.
Habt ihr eine Idee?
Liegt es vielleicht an der Ausgedruckten Strecke (zu dünn, zu scharfe Kurven, zu glänzend wegen Laserdrucker ????) ich weiß es nicht.
Also wäre nett wenn ihr vllt eine Lösung wüsstet.
Mein Asuro ist übrigens im Originalzustand falls das wichtig ist ;)
Hallo,
wenn der Asuro die Linie verliert kannst du dir dadurch behelfen, indem du eine kleine Manschette machst, die du über Photodioden und FrontLed steckst.
Viel bringt auch den Liniensensorumbau zu machen und die Bauteile einzustecken. Dadurch kommen sie näher an die Linie. Du hast ausserdem den Vorteil dass du mit verschiedenen Front-LEDs experimentieren kannst.
Moglicherweise musst auch nur das Programmparameter besser an die Liniensensorgruppe anpassen.
ich hab sie steckbar gemacht und ich hab auch schon n schrumpfschlauch drüber gesteckt aber das hat nie sehr viel geholfen wobei ich damals auch noch nich das programm mit pid regler hatte sondern das beispiel programm
also bin dann doch direkt in den super Elektronik Laden in Freiburg gegangen und hab mir einen Meter Schrumpfschlauch und Isolierband gekauft und hab mir auf meinem Tisch einen Kreisgeklebt und siehe da es funktioniert ich weiß nicht was ich immer falsch gemacht habe aber es geht
er fährt zwar nicht ganz flüssig also er ruckelt immer hin und her aber er fährt der Linie nach *freu*
Vielen Dank vielleicht weiß jemand wie ich das ruckeln noch beheben kann aber Hauptsache ist erstmal das er der Linie nachfährt :)
Habe das Programm von waste runtergeladen, es funktioniert super !! Asuro's von meinen Zwilingen folgen tatsächlich der Linie! Beide!
Nur wenn ich selber kompiliere, tut nichts, also wie pult im Forum schon geschrieben hat, beim Starten des Asuro leuchtet die linke Back-LED auf.
Das liegt wahrscheinlich an den Libs.
Kann man die Libs irgendwo runterladen?
Würde das Programm gerne erweitern, dass auch die Sensortaster abgefragt werden...
Kann mir jemand helfen?
hallo,
hier mein versuch den code für den RP6 "umzuschreiben"...