Also ich habe mir das einmal mit dieser Methode durch den Kopf gehen lassen (Einstellung nach der Schwingungsmethode, Quelle: http://www.rn-wissen.de/index.php/Regelungstechnik ). Ich verstehe aber folgende Sachen nicht: -Ich habe mich in vielen Foren über den PID Algorithmus informiert und auch auf vielen Seiten und stelle fest, dass manche mit einem Modell für den Motor arbeiten und die Drehzahl messen und regeln (das steht auch auf der RN Seite weiter unten). Im Bascom Forum schreibt einer, dass man nur die Regeldifferenz dem PID Algorithmus (der nebenbei mal dieser zu darstellen scheint: y = Kp*Regeldifferenz + Ki*Ta*esum + (Kd*((Regeldifferenz -ealt)/Ta)); ) übergeben wird und dadurch Werte ausgerechnet werden, die man dann für die Motoren verwenden kann. Brauche ich nun ein Modell und eine Drehzahmessung oder stellt meine Regelstrecke meine Motoren dar und meine Rückführgröße meine 5 Liniensensoren? -Ich verstehe nicht wie das y(Die Ausgangsgröße) mit derm Motor zusammenhängt. Dh woher soll der PID ALgorithmus wissen, dass der ein Motor ansteuern soll? Auf der RN Seite steht zwar alles beschrieben für PID, aber es erkärt nicht wie man PID anwendet. Beispiel: das y das resultiert ist die Stellgröße die ich für die Motoren einsetzen muss. Aber wie stelle ich das an? Nehmen wir mal an ich wende die erste Methode aus um meine PID Parameter (optimal) zu machen, dh durch Ausprobieren (zuerst den P Anteil, Dann I und dann noch D falls notwendig), wie kann ich dann damit eine PWM von 8 Bit ansteuerun wenn der Sollwert größer als 8 bit ist? Ich könnte zwar jetzt auf 10Bit PWM Modi gehen aber der Punkt ist: Der Regelalgorithmus weiß gar nichts von der Ansteuerung des Motors und das ist ein Problem. Gruß Bro
Brocken Sei schrieb: > Der > Regelalgorithmus weiß gar nichts von der Ansteuerung des Motors und das > ist ein Problem. Der Regelalgorithmus weiss auch nicht, dass er ein Regelalgorithmus ist. Und ja, er weiss auch nichts von der Ansteuerung des Motors. Aber du weisst das und kannst daraus deine Erkenntnisse und Konsequenzen ziehen. Was ist genau das Problem?
Ich glaub du solltest dir erstmal die grundlegenen Sachen zur Regelungstechnik durchlesen. Evtl ne Simulationsprogramm dabei und das ganze mal am Rechner durchtesten bis du die Regler einigermaßen verstanden hast. Das klingt alles so als wenns an den Grundlagen hapern würde.
> Brauche ich nun ein Modell und eine Drehzahmessung oder stellt > meine Regelstrecke meine Motoren dar und meine Rückführgröße > meine 5 Liniensensoren? Gegenfrage: Was willst du ueberhaubt regeln und was kannst du? :-) Wenn du die Drehzahl regeln willst dann musst du das selbstverstaendlich auch tun. Wenn du nur eine Position regeln musst dann koenntest du darauf verzichten weil es dir ja vielleicht egal ist wie schnell dein Motor ans Ziel kommt. Was du willst, wissen wir nicht. Wenn du nun total ein total faehiger Regelungstechniker waerst dann koenntest du vielleicht einen Algorythmus schreiben der deinen Motor komplett regelt. In der Praxis ist es klueger es so zu machen: 1. Du programmierst einen inneren Regler welcher den Motorstrom regelt. Es ist besser den Motorstrom zu regeln und nicht die Spannung weil der Zusammenhang dann linear wird. Ausserdem kann man dann die Regelung abbrechen wenn Grenzwerte ueberschritten werden. Dann braucht man nicht jedesmal einen neuen Motor kaufen wenn etwas mechanisch blockiert ist. 2. Du ueberlagerst dem Stromregler einen Drehzahlregler. Der regelt die Drehzahl indem er dem Stromregler die Sollwerte vorgibt. Auch hier kannst du Grenzen vorgeben. Schliesslich macht nicht jede mechanik beliebige Drehzahlen mit. 3. Und als letztes machst du dann einen Positionsregler der wiederum den Drehzahlregler ansteuert. Das ganze nennt man (Google-Hint) Kaskadenregler. Ein weiterer Vorteil dieser Vorgehensweise, du arbeitest von Innen nach aussen und kannst so in aller Ruhe jeden einzelnen Teil erstmal ans laufen bringen. > wie kann ich dann damit eine PWM von 8 Bit ansteuerun wenn > der Sollwert größer als 8 bit ist? Das Zauberwort heisst skalieren. Du beziehst halt alles auf 256. Das bedeutet natuerlich nicht das du Reglerintern nur mit 8Bit Datentypen rechnen kannst! Nur deine Regelparameter sollten halt so ausgelegt sein das sie in etwa in der Groesse bleiben. Wenn du ganz am Schluss dann mal etwas groesser bist dann begrenzt du einfach den Wert. > Ich könnte zwar jetzt auf 10Bit PWM Modi gehen aber der Punkt ist: Das waere vermutlich uebertrieben. > Der Regelalgorithmus weiß gar nichts von der Ansteuerung des > Motors und das ist ein Problem. Naja, es ist deine Aufgabe da eine Beziehung anzubahnen. :-D Olaf
Olaf schrieb: >> Der Regelalgorithmus weiß gar nichts von der Ansteuerung des >> Motors und das ist ein Problem. > > Naja, es ist deine Aufgabe da eine Beziehung anzubahnen. :-D Exakt. Da ich Bocken Sei schon länger verfolge, weiß ich zufällig, dass er an einem Roboter arbeitet, konkret einem Linienverfolger. Sein Eingangswert ist Mass für die Abweichung der Sensorern von der zu verfolgenden Linie Sein Stellwert ist ein Lenkausschlag (und keine Motordrehzahl oder was auch immer). Sein PID Regler soll jetzt die Lenkung so nachstellen, dass der Robot mit den Sonsoren auf der Linie bleibt Da muss er halt mal ein paar Definitionen machen. Zb. Ein Eingangswert von 128 bedeutet, dass die Senosren auf der Linie sind. Kleinere Wert: Abweichung nach links Größere Werte: Abweichung nach rechts Sein Stellwert ist ein Mass für den Lenkeinschlag. Stellwert 128: geradeaus fahren Stellwert kleiner 128: nach links fahren Stellwert größer 128: nach rechts fahren Der PID Regler stellt einfach nur eine Beziehung zwischen diesen beiden Größen her. Wie dann der Lenkeinschlag realisiert wird, ob da jetzt eine Achse angesteuert wird, oder ob da Motoren links und rechts unterschiedlich schnell laufen, interessiert den PID Regler nicht. Der kümmert sich nur darum, dass bei einer Abweichung nach rechts als Konsequenz nach links gegengelenkt wird. Wenn es sich beim Einsatz des PID allerdings gar nicht um die Lenkung handelt, dann bitte ich um Entschuldigung und ziehe mich auch gleich wieder zurück. > wie kann ich dann damit eine PWM von 8 Bit ansteuerun wenn der > Sollwert größer als 8 bit ist? Genauso wie in einem Auto auch: Wenn du eigentlich das Lenkrad 3 Umdrehungen nach links drehen müsstest, aber nach 2 Umdrehungen schon anstehst, dann wirst du eben nicht 3 Umdrehungen drehen können. Deine Vorgabe war: einen Bogen mit einem Radius von 80 Zentimeter zu fahren und durch den begrenzten Lenkeinschlag geht das nun mal nicht. Der Bogen wird dadurch weiter und du kommst an einer anderen Position raus als vorherberechnet wodurch zusätzlicher Aufwand entsteht diese Abweichung zu korrigieren.
Karl heinz Buchegger schrieb: > Sein Stellwert ist ein Mass für den Lenkeinschlag. > Stellwert 128: geradeaus fahren > Stellwert kleiner 128: nach links fahren > Stellwert größer 128: nach rechts fahren Dieses Muster habe ich leider nicht, weil meine Sensoren weit auseinander eingelötet sind. Daher ist zwischendurch mal ein kleinerer Wert als sein sollte. Eine Idee wäre vielleicht das mit Soll = 0 und kleiner 0 --> Links größer 0--> rechts Ich wüsste aber nicht ob das mit PID so funltioniert. Das is aber auch ne Schätzungssache, denn darauf habe ich und PID keinen Einfluss ob die Übergänge von Sensor zu Sensor perfekt sind. Gruß Bro
Karl heinz Buchegger schrieb: > Der > kümmert sich nur darum, dass bei einer Abweichung nach rechts als > Konsequenz nach links gegengelenkt wird. ja aber bringt mir das dann auch mehr als wenn ich normal ansteuere? Eins verstehe ich noch nicht: Du sagtest das Beispiel mit 128, größer:links, kleiner:rechts. Das deutet doch darauf hin (da es reine Mathematik ist) dass es nur so funkrionieren kann wie du es gesagt hast, weil ich ja negative Werte ausschließen muss, da sinst die Mathematik nicht mitspielt(PID Algo). Ich habe aber 3 Sensoren und diese agieren bei ihrer Anordnung wenn ich die Wertigkeiten zusammenzähle nicht so wie du beschrieben hast, weil sie etwas weiter auseinander gelötet sind, dh zwischendurch ist zu wenig. Dh diese Methode:
1 | HP:
|
2 | Sensor1 = (long)GetADC_8bit(1) * 1; |
3 | Sensor2 = (long)GetADC_8bit(2) * 2; |
4 | Sensor3 = (long)GetADC_8bit(3) * 3; |
5 | |
6 | Summe = Sensor1 + Sensor2 + Sensor3; |
7 | JMP HP |
8 | |
9 | OVERFLOW_TIMER0: |
10 | esum = esum + Summe; //Integration I-Anteil |
11 | y = Kp*Summe + Ki*Ta*esum + (Kd*((Summe-ealt)/Ta)); //PID-Regelalgorithmus |
12 | ealt = Summe; |
13 | RETI
|
kann ich schmeißen weil ich zwischendurch keine richtigen Werte habe. Ich könnte höchstens versuchen mich mit dem Faktor mal GetADC(x) spielen, damit ich einen halbwegs richtigen Übrgang kriege, jedoch dann habe ich ein Problem wenn der Roboter ganz rechts steht denn dann ist der Wert enorm und der PID Algorithmus wird sagen Kp * Wert, und die Motoren werden maximal angesteuert auch wenn ich so gut skaliere wie es geht wird es eine gewisse unsymmetrie geben. Deswegen meine Frage. Gruß Bro
Brocken Sei schrieb: > Eins verstehe ich noch nicht: > Du sagtest das Beispiel mit 128, größer:links, kleiner:rechts. > Das deutet doch darauf hin (da es reine Mathematik ist) dass es nur so > funkrionieren kann wie du es gesagt hast, weil ich ja negative Werte > ausschließen muss, da sinst die Mathematik nicht mitspielt(PID Algo). Sagt wer? > Ich habe aber 3 Sensoren und diese agieren bei ihrer Anordnung wenn ich > die Wertigkeiten zusammenzähle nicht so wie du beschrieben hast, weil > sie etwas weiter auseinander gelötet sind, dh zwischendurch ist zu > wenig. Dann musst du dir was einfallen lassen! > kann ich schmeißen weil ich zwischendurch keine richtigen Werte habe. Dann solltest du damit anfangen, deine 3 Sensorwerte so miteinander zu verrechnen, dass du eine schöne Zahlenreihe bekommst, die monoton steigend ist. Je weiter dein Robot links von der Linie ist, desto kleiner die Zahl. Je weiter dein Robot rechts von der Linie ist, desto größer die Zahl Und wenn geht sollte das auch einigermassen linear sein (ist aber nicht sooooo wichtig) D.h. bei genau über der Linie kriegst du einen Zahlenwert x ( von mir aus 0) Ist dein Robot 2 Zentimeter links von der Linie, dann ergibt sich ein Wert y, wobei z = x - y Ist dein Robot 2 Zentimter rechts neben der Linie, dann soll sich ein Wert w, ergeben mit z = w - x (Mit anderen Worten: bei gleicher ABlage von der Mitte, zb 2 cm, ergibt sich links und rechts dieselbe Abweichung im Messwert von der Mittelposition) Liefert deine Auswertung zb 0 wenn der Robot in Mittelstellung ist, dann könnte er bei 2cm zu weit links einen Wert von (hausnummer) -20 liefern und bei 2cm zu weit rechts einen Wert von +20 Ob der die Sensoren bei 4cm Abweichung dann auch -40 bzw +40 liefern ist nicht mehr so gravierend. Und dem Regler gibt man dann eben vor, dass er einen Sollwert von 0 ausregeln soll. Ein PID Regler steht und fällt mit den Werten für Kp, Kd und Ki. Die legen die Regelcharaktersitik fest. Ob der Regler schwingt, wie schnell er reagiert, wie gut er ausregelt, etc. Und PS: die lineare Gleichung ist schon erfunden. Wenn du Werte im Bereich -50 ... +50 hast und du zählst zu allen Wetren einfach 50 dazu, dann bewegen sich deine WErte plötzlich im Bereich 0 ... 100. Vorher war die 'Mittelposition' bei 0, nach der Addition ist sie dann bei 0 + 50 = 50.
Karl heinz Buchegger schrieb: > Und PS: die lineare Gleichung ist schon erfunden. > > Wenn du Werte im Bereich -50 ... +50 hast und du zählst zu allen Wetren > einfach 50 dazu, dann bewegen sich deine WErte plötzlich im Bereich 0 > ... 100. > Vorher war die 'Mittelposition' bei 0, nach der Addition ist sie dann > bei 0 + 50 = 50. Genau das macht doch die ganze Sache so unsicher für mich, ich spiel mich da mit irgendwelchen Zahlen herum, und es ist sowieso nicht fix da was nützliches herauskommt, obwohl alle sagen : DAS FUNKTIONIERT! Ich glaube aber es steckt mehr hinter all dem, naja ich werds wohl rausfinden mit der Zeit. Aber starke Erklärung. Gruß Bro
Karl heinz Buchegger schrieb: > Dann musst du dir was einfallen lassen! Ich habe mir jetzt weitere cny70 bestellt und werde diese dann durch Ausbrobieren näher beieinander auflöten, also dann müsste es von der Hardware aus sein. jetzt zur SOftware: Zwar kann ich noch nichts genaueres ausprobieren, da die BEstllung noch auf trip ist, aber ich habe mir folgendes COding überlegt: Ich habe die PWM auf 10 Bit gestellt, so habe ich jetzt 1024 Möglichkeiten, und voll fahren tu ich mit genau der Hälfte! Damit ich 512 + - bei beiden Motoren erreichen kann ,so wird es vorgeschlagen in einem Forum. Und da habe ich folgendes überlegt:
1 | //Main-Loop:*********************************************************************
|
2 | while(1) |
3 | {
|
4 | //lcd_clear();
|
5 | summe = 0; |
6 | |
7 | sensorL1 = (long)GetADC_8bit(0) * 1; //Sensor ganz Links |
8 | sensorL0 = (long)GetADC_8bit(1) * 2; //Sensor Links |
9 | sensorM = (long)GetADC_8bit(2) * 3; //Sensor Mitte |
10 | sensorR0 = (long)GetADC_8bit(3) * 4; //Sensor Rechts |
11 | sensorR1 = (long)GetADC_8bit(4) * 5; // Sensor ganz Rechts |
12 | |
13 | summe = sensorL0 + sensorL1 + sensorM + sensorR0 + sensorR1; |
14 | |
15 | if((summe > (sollwert - 5)) && (summe < (sollwert + 5))) //Wenn Sollwert, dann Motoren beide voll |
16 | {
|
17 | MotorLINKS = ON; |
18 | MotorRECHTS = ON; |
19 | }
|
20 | else if(summe < (sollwert - 5)) //ansonsten mehr links |
21 | {
|
22 | MotorRECHTS = 0; //Damit jede Abweichung neu calculiert wird! |
23 | summe = summe - sollwert; //errechne Abweichung |
24 | MotorLINKS = OFF; //(MotorLINKS -= y;) |
25 | MotorRECHTS += y; //ON von vorher + Abweichung, die vom PID modifiziert wird |
26 | }
|
27 | else if (summe > (sollwert + 5)) //oder mehr rechts |
28 | {
|
29 | MotorLINKS = 0; //Damit jede Abweichung neu calculiert wird! |
30 | summe = summe - sollwert; |
31 | MotorLINKS += y; //ON + Abweichung, die vom PID modifiziert wird |
32 | MotorRECHTS = OFF; //(MotorRECHTS -= y;) |
33 | }
|
34 | |
35 | }
|
36 | //back***************************************************************************
|
37 | return 0; |
38 | }
|
39 | |
40 | ISR(TIMER0_OVF_vect) |
41 | {
|
42 | esum = esum + summe; //Integration I-Anteil |
43 | y = Kp*summe + Ki*Ta*esum + (Kd*((summe-ealt)/Ta)); //PID-Regelalgorithmus |
44 | ealt = summe; //Differzenteil |
45 | }
|
Somit fahre ich bei Abweichung = Sollwert immer nur die Hälfte aber ich kann besser Lenkeinschläge machen weil ich automatisch einen Spielraum von 512 Werten im + und - Bereich habe. Ist das eine vernünftige Lösung? Gruß Bro
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.