regelt nicht nach

hallo zusammen,

ich komme wieder mit dem gleichen Problem, aber jezt, um eine 
zustimmung meine Idee zu haben.
im wikipedia habe ich heute was gelesen und ich denke, wenn dies Wahr 
ist, könnte es sein, der Grung Warum  mein Regler nicht nachregelt.
Im PI Regler habe ich eine Begrenzung von esum bzw. yi eingesetzt: 
Windu Effekt
        ki*Ta*esum= ymax  --> esum=ymax/(ki*Ta)  oder esum=yMin/(ki*Ta)
In Mein Program wie Ganz oben beschrieben wurde, beim belasten geht die 
stellgröße in eine Richtung und bleibt an der Grenze.
jetzt habe ich gelesen, dass die I-Anteil muss auf die 
Stellgröße-Grenzen entgegen begrenzt.  wenn ich gut verstande , das 
bedeutet für mich:

if (esum <yMin){
   esum = -ymin;
}
else
if(esum > yMax){
  esum = -yMax
}

könnte jemand mir diese zustimmen? oder was dazu sagen

Schönes Wochenende

1

x_normiert= (x * 1000);        // Normierung

2

w_normiert= (w * 1000);        // 

3

e_normiert=(x_normiert-w_normiert);    

4

e= (e_normiert)/1000;

Warum da erst mit 1000 multiplizieren um es dann wieder durch den Wert 
zu teilen?

e = x - w ergibt genau das gleiche und e_normiert nutzt du ja sowieso 
nicht weiter.

----------------------------------------------------------------------

1

yp_normiert/1000;

Was macht diese Zeile?

----------------------------------------------------------------------

1

int PID_Berechnung( int x, int w)

2

...

3

y=y_normiert/1000  ;         // Stellglied der Regler

4

5

if(y<2500){

6

   y=2500;                               

7

}

8

else if(y>3000){

9

   y=3000                        

10

}

11

12

return y;

Dein Datentyp für y scheint int zu sein. Int wird je nach System anders 
interpretiert, je nach Wortbreite deines Systems. Bei einem 8-Bit-System 
hat int auch nur 8 Bit, beim 16-Bit-System dementsprechend 16 Bit usw. 
Da du nichts zu deinem System sagst, ist int ersteinmal nichtssagend. 
Was man nur sagen kann: Bei 8 Bit wäre sowieso bei 255 Schluss, da ist 
an Werte von 2500 oder 3000 nicht zu denken für y und bei 16-Bit wird 
dir deine komische 1000-Normierung Probleme bereiten, wenn dein 
y_normiert auch int ist. Als Tipp: Schau dir mal die Datentypen int8_t, 
int16_t, int32_t usw an, da siehste nämlich sofort wieviel Bit du in so 
einer Variable speichern kannst.

kann ich dir nicht zustimmen.
Sah vorher besser aus.

Aber da sind noch einige Zeilen seltsam...


Ich muss ehrlich gesagt zugeben, dass dein Text etwas anstrengend zu 
lesen ist ;)


folgende Vorschläge zum suchen:
- wird das Ergebnis deiner Berechnungen jedesmal irgendeiner Variablen 
zugewiesen?
- machen die Normierungen immer Sinn? nicht dass da mal ein Faktor 1000 
übrig bleibt
- ist die Abtastrate des Algorithmus konstant und richtig gewählt?
- D-Anteile schwingen, I-Anteile können instabilität verursachen (bei 
niedriger Abtastrate sieht beides gleich aus)

Michael H. schrieb:
> Thorsten schrieb:
>> Warum da erst mit 1000 multiplizieren um es dann wieder durch den Wert
>> zu teilen?
> Festkommaarithmetik

War mir klar, dass das kommt. In diesem Fall ist das aber unnötig.

1

x_normiert= (x * 1000);        // Normierung

2

w_normiert= (w * 1000);        // 

3

e_normiert=(x_normiert-w_normiert);    

4

e= (e_normiert)/1000;

x_normiert und w_normiert sind beides Zahlen, die mit drei Nullen enden. 
Ziehe ich den einen vom anderen ab, bleiben bei e_normiert immer noch 
drei Nullen am Ende, wieder durch 1000 geteilt, ändert sich nichts im 
Vergleich zu dem Fall, wenn man direkt e = x-w gerechnet hätte.