volle Verzweiflung, wo liegt der Fehler :-(((((

Warum debuggst du dein Programm nicht Schritt für Schritt.
Dafür ist der Debugger nämlich da.
Haste kein Main (void)-Funktion geschrieben?
Und wie wird die Solldrehzahl eingegeben?

@AC/DC:

hier ist das Debuggen nicht möglich, da das ganze ja ein physikalischer 
Prozess ist. Im Einzelschrittmodus hat man keinen zusammenhängenden 
Prozess mehr.
Ein Main hab ich schon geschrieben, ist hier nicht von Bedeutung, da da 
nur Sachen initialisiert werden etc.

na dann bau Dir doch nen kleinen Motor zum Spielen / Simulieren ..

Nimm die neuberechnung für deinen I-Anteil aus der If bedingung raus.

Dann den I - Anteil begrenzen auf z.B. +- 10 oder +- 15

Dann den P- Anteil begrenzen  auf z.B. +- 15 oder +- 20

Dann summieren

Dann alles begrenzen auf 20 bis 400


Ich denke, dass bei deinem log die untere Begrenzung bei 30 lag. Wenn 
deine Stellgroße nun kleine als 30 ist (z.B. P =15, I= 5), wird dein I 
Anteil niemals größer. also reiner  p_ Regler mit offset, da I=konstant.

@AC/DC:

>hier ist das Debuggen nicht möglich, da das ganze ja ein physikalischer
>Prozess ist. Im Einzelschrittmodus hat man keinen zusammenhängenden
>Prozess mehr.

Meine Frage nach der Sollwertangabe hast du leider nicht beantwortet.

Also nach einer Dokumentation über das Debuggen macht es keinen Sinn
wenn Echtzeit oder die Aktion/Reaktion der Hardware getestet werden 
soll.
(Ich vermute da du das mit physikalischer Prozess meinst)
Wenn du mit printf Werte ausgibst ist das für mich sehr wohl debuggbar.
Aber mach man es so wie du das für richtig hälst. Vielleicht bin ich mit
meinem Vorschlag ja auf dem Holzweg. Habs ja nur gut gemeint.

Wie bereits schon festgestellt:

Liegt dein Stellwert unter der Mindestgrenze, hat dein I-Anteil keinen 
Einfluss mehr -> P-Regler -> bleibende Regelabweichung

@ gast und gast 99:

also normalerweise würde ich die untere Grenze der Stellgröße auf 0 
begrenzen. Das Problem dabei ist, dass bei Stellgröße=0 die 
Motordrehzahl auch = 0 U/min wird. Heißt: Motor dreht sich nicht.
Meine Drehzahlbestimmung erfolgt mittels Interrupt, der bei jedem pos. 
Impuls des Encoders ausgelöst wird. Das bedeutet, wenn sich der Motor 
nicht dreht, dann kann auch keine Drehzahlbestimmung mehr erfolgen und 
es kann nicht festgestellt werden, dass die aktuelle Motordrehzahl = 0 
ist. Es wird mit dann mit alten Werten geregelt und nicht mit den 
aktuellen.

@ Läubi Mail@laeubi.de
könntest du mir das bitte genauer erklären.
Wie definier ich denn den Timeout???

Du überprfts bei einer bestimmten anzahl von interrupten, wieviel zeit 
vergangen ist?

Überprüfe doch in regelmäßigen zeitabständen, die anzahl der interrupte 
und mache dann einen reset.

Wenn du in der unteren begrenzung bist, kann dein I anteil die bleibende 
regelabweichung nicht mehr ausregeln.

Was macht deine regelung denn bei einer sollgröße (z.B. 1500 U/min), bei 
der deine stellgröße nicht in der begrenzung arbeitet?

@ Karl heinz Buchegger:
hab ich doch schon lang getan, hab noch nicht gepostet gehabt, weil es 
noch nicht optimal läuft.
Den I_Anteil hab ich zufälligerweise auch auf +/-1000 begrenzt. Hab es 
aber auch mit anderen Werten ausprobiert, der Regler verhält sich bei 
verschiedenen Drehzahlen anders, heißt bei 500 u/min ist die Begrenzung 
von 1000 gut, bei 1000u/min eine andere....

@ Karl heinz Buchegger:
ja, der Motor bewegt sich total ruckartig und manchmal regelt er sich 
nicht auf die Solldrehzahl ein. Z.B. bei einer niedrigen Solldrehzahl 
von unter 300, schwingt er sich auf ne Drehzahl von ca. 70 ein.
Vielleicht sollte ich wirklich an dem Kp noch drehen.....??

Ein Motor hat eine statische (konstant) und eine dynamische (in 
Abhängigkeit von der Drehzahl) Reibung. Beides muss man (zumindest) 
näherungsweise bestimmen und dann kompensieren.

Mit einfach an einem Parameter drehen wird es echt schwer. Gib doch 
einmal genauere daten zum Motor (Datenblatt?).

@gast:
hab das Datenblatt reingestellt.

sodala, jetzt hab ich ein bisschen was geändert, denn die 
Stellwertbegrenzung:

1

if(Stellwert <= 0)      // Begrenzung nach unten, also auf FE6F

2

  {

3

    Stellwert = 30;

4

5

  }

stimmt ja nicht. Das hab ich nur vorläufig so gemacht, weil bei 
Stellwert = 0(das wär die richtige Begrenzung), die Drehzahl auch auf 0 
gesetzt wird.

Die Drehzahlermittlung geschieht aber nur bei nem Interrupt durch pos. 
Impuls vom Encoder. Das würde heißen: es kann nicht festgestellt werden, 
dass die Drehzahl = 0 ist.
Jetzt hab ich es so geändert:

1

Drehzahl_mot =(unsigned int) (Drehz_sum/Durchlauf);

2

    if (Stellwert_alt == 0)

3

    {

4

      Drehzahl_mot = 0;

5

      Drehz_sum = 0;

6

      Durchlauf = 0;

7

8

    }

in Drehz_sum ist die Summe der Drehzahlen über eine Umdrehung (500 
Impulse).

Die Ausgabe der Werte, hab ich angehängt. Etwas haut da nicht hin....
Wieso zeigt er mir die pi_r. Stellwert so komisch an?

Ausgabe:

1

printf("%d\t%d\t%d\t%d\t%d\t\n",Istdrehzahl,

2

                                pi_r.Regelabweichung,

3

                                pi_r.I_Anteil,

4

                                Stellwert,

5

                  pi_r.Stellwert);

pi Struktur:

1

struct PI_Regler                   // Motorregler, realisiert als PI-Regler

2

{

3

4

unsigned int Sollwert;

5

unsigned int Istwert;

6

unsigned int Stellwert;     

7

signed int Regelabweichung;     // kann auch negativ werden  

8

signed long int I_Anteil;         // kann auch negativ werden 

9

10

11

int Kp;

12

int Ki;

13

int Ta;    // Abtastzeit = Zeit zw. 2 Drehzahlmessungen

14

15

}pi_r;

Hab die Ausgabe jetzt berichtigt. Hab aus dem I-Anteil auch nen unsigned 
int gemacht.
Gestern ist mir noch ein Fehler aufgefallen und zwar: die Aufrufperiode 
des Reglers war größer als die Streckenzeitkonstante des Reglers (=Ta 
beim PT1=12,77ms).
Hab die Aufrufperiode jetzt auf ca. 1ms reduziert.
Außerdem wurde mir empfohlen, die Periode von PWM auch auf ca. 1ms 
einzustellen, ich hatte sie viel schneller eingestellt gehabt.
Weiß jemand warum?
Ich hab es schon gemacht, bin jetzt auch im hörbaren Bereich und es 
piepst schrecklich...

sodala, die Abtastzeit beträgt jetzt 1,6ms.
Der Code sieht so aus:

1

//*************************************************************************************

2

//                     Funktionen

3

//*************************************************************************************

4

extern int PI_Init(void)

5

{         

6

pi_r.Kp = 1;

7

//pi_r.Ki = 12; // Ki = 1,2

8

pi_r.Ki = 10;

9

pi_r.Ta = 16;  // Ta ist 1,6 ms

10

11

12

Begrenzung = 0;

13

pi_r.I_Anteil = 0;

14

pi_r.Regelabweichung = 0;

15

16

return 0;

17

}

18

//*************************************************************************************

19

20

unsigned int Regeln (unsigned int Istdrehzahl)

21

{

22

23

signed int Stellwert = 0;

24

25

  pi_r.Istwert=Istdrehzahl;

26

27

  //printf("Istdrehzahl: %d",pi_r.Istwert);

28

  //printf("\n");

29

30

  pi_r.Sollwert=Solldrehzahl;  

31

  pi_r.Regelabweichung = pi_r.Sollwert-pi_r.Istwert;     // e=w-x

32

33

34

  //         Antiwindup     

35

36

    pi_r.I_Anteil = pi_r.I_Anteil + pi_r.Regelabweichung;          // esum=esum+e

37

38

    if( pi_r.I_Anteil > 100 )

39

       pi_r.I_Anteil = 100;

40

41

       if( pi_r.I_Anteil < -100 )

42

       pi_r.I_Anteil = -100;  

43

44

45

  Stellwert = (pi_r.Kp*(pi_r.Regelabweichung))/5 + ((pi_r.Ki*pi_r.I_Anteil)*pi_r.Ta)/10000;  //Ta= 210ms, nicht durch 1000, weil  Ki=12/10

46

47

48

  if(Stellwert <= 0)      // Begrenzung nach unten, also auf FE6F

49

  {

50

    Stellwert = 0;

51

52

  } 

53

54

   if(Stellwert > 400)    // Begrenzung nach oben, also auf FFFF

55

  {  

56

    Stellwert =400;

57

  }

58

59

Stellwert_alt = Stellwert;     

60

pi_r.Stellwert = MIN + Stellwert;

61

62

printf("%d\t%d\t%d\t%d\t%u\t\n",Istdrehzahl,

63

                                pi_r.Regelabweichung,

64

                                pi_r.I_Anteil,

65

                                Stellwert,

66

                  pi_r.Stellwert);    

67

68

69

  return pi_r.Stellwert;      // Übergabe Stellgröße

70

}

Hab die Werte, die ich beobachte angehängt. Irgendwie ist es jetzt so, 
dass dass egal wie ich mein Ki verändern tue,  sich nichts ändert. Ich 
hatte Ki zwischen 1 und 10000 und meine geregelte Istdrehzahl hat sich 
nicht geändert.

@ Karl heinz Buchegger:
also an der Begrenzung des I-Anteils ist es nicht gelegen. Egal ob ich 
auf 100, 1000 oder 10000 begrenzt habe, hatte ich das gleiche Verhalten.

Habe das Problem jetzt orten können(aus Eigeninitiative :-)).
Wenn ich Ki=100 genommen habe und die Reglergleichung so:

1

Stellwert = ((pi_r.Kp*(pi_r.Regelabweichung))/5) + (((pi_r.Ki*pi_r.I_Anteil)*pi_r.Ta)/10000);

dann hat es nicht funktioniert und er hat nie auf den Sollwert geregelt. 
Wenn ich allerdings Ki=1 hatte und die 100 mit den 10000 verrechnet hab 
(mathematisch eigentlich das Gleiche).
Die Gleichung schaut so aus:

1

Stellwert = ((pi_r.Kp*(pi_r.Regelabweichung))/5) + (((pi_r.Ki*pi_r.I_Anteil)*pi_r.Ta)/100);

Dann hats funktioniert. Erklären hab ichs mir noch nicht können, bin 
eingentlich durch Ausprobieren drauf gekommen. Werd mir jetzt noch 
Gedanken machen, wieso es so funktioniert und anders nicht.
Ach ja, die /10000 kommen von der Abtastzeit von 1,6ms.
Die hatte ich am Anfang 0,2 s gewählt und die war eindeutig zu groß 
gewählt (auch Eigeninitiative!!!).

Jetzt weiß ich auch warum ich falsche Werte hatte: bei 16 Bit Register 
hat meine Berechnung nen Überlauf verursacht!

@ Karl heinz Buchegger:
bin schon drauf gekommen, danke.

Vielleicht mag es Dich trösten,
ein ähnlicher Fehler wie dieser führte 2002 zum Absturz der Ariane 5 auf 
ihrem Jungfernflug.

@Thomas:
na dann bin ich ja froh, dass ich den Fehler noch beheben konnte :-)