Hilfe PI-Regler Realisierung

[Meier (Gast)]

Hallo,

kann sich villeicht jemand mal meine nachfolgende Realisierung eines 
PI-Reglers in Festkommaarithmetik anschauen und mir sagen wo noch 
Verbesserunsgpotentiale oder auch Fehler sind?
Der Regler geht als Stellwert an eine 8bit PWM.

Insb. hab ich jetzt durch die vielen 16bit Variablen das Problem das 
mein Programmspeicher fast voll ist. Wo kann ich noch einsparen?

Und wie sollte die Grenze für den Anti Wind-up des I-Anteils gewählt 
werden?

Gruss

#define KP      1
#define KI      0
#define TA      0.1  //Abtastzeit 100ms




uint8_t pi_regler(int16_t regelabweichung)
{
  int16_t p_anteil,i_anteil,pi_regler_output;
  
  static int16_t regelabweichung_summe=0;
  
  regelabweichung=regelabweichung/8;        //vom Format S(11,4) zu S(14,1)
  
  //Bestimmung P-ANTEIL
  p_anteil=(p_factor*regelabweichung)/2;
  
  //Bestimmung I-ANTEIL
  regelabweichung_summe+=regelabweichung;
  
  
  //Begrenzung I-Anteil
  if(regelabweichung_summe<0)
  {
    regelabweichung_summe=0;
  }
  
  if(regelabweichung_summe>(255*2))      //Regelabweichung Summe im Format S(14,1)
  {
    regelabweichung_summe=(255*2);
  }
  
  
  i_anteil=(i_factor*regelabweichung_summe)/2;
  
  //Bestimmung RUECKGABEWERT
  pi_regler_output=(p_anteil+i_anteil)/16;
  
  
  if(pi_regler_output>255)
  {
    pi_regler_output=255;
  }
  
  
  if(pi_regler_output<0)
  {
    pi_regler_output=0;
  }
  
  return (uint8_t) pi_regler_output;
  
}

[Morz Kerl (Gast)]

Ausprobieren ?

[Tom K. (ez81)]

>>mein Programmspeicher fast voll ist.
>> #define TA      0.1   wird in diesem Ausschnitt zwar nicht benutzt,
aber landet die falsche floating point lib in deinem Hex?

[Martin S. (drunkenmunky)]

Funktioniert das denn, was du hier zusammenprogrammiert hast?

Kannst dir auch mal das hier anschauen:
http://www.rn-wissen.de/index.php/Regelungstechnik

[Meier (Gast)]

hi,

sorry, hab noch zwei defines vergessen:

#define p_factor  (KP*16)
#define i_factor  (KI*TA*16)

Wie kann ich heraus finden ob dadurch die floating point lib eingebunden 
wird?


Der P-Anteil funktioniert mal soweit. Beim I-Anteil bin ich mir nicht so 
sicher. Desweitern tue ich mir auch gerade schwer die Regelparameter zu 
bestimmen.

[Meier (Gast)]

Volltreffer mit der folating point lib!

Wurde eingebunden. Danke für den Tip!!

[Tom K. (ez81)]

Wenn Du float brauchst, das hier beachten, um keinen Speicher zu 
verschwenden: Beitrag "Re: Programmspeicher beim Tiny26 voll"

[Meier (Gast)]

Hallo,

hab das ganze nun nochmal etwas überarbeitet. Und versuche nun die 
Regelparameter zu ermitteln... Komme aber einfach nicht weiter und weiss 
auch nicht richtig woran es liegen könnte.

Bei einem KP von 1 (KI=0) kommt das ganze ins Schwingen. Könnte 
vielleicht der ein oder andere Reglungstechnik Profi hierzu was sagen?
Bzw. mir einen Anhaltspunkt geben mit welchem KP ich Anfangs beginnen 
sollte?

Angeschlossen ist ein kleiner Heizstab und als Sensor kommt ein DS18B20 
zum Einsatz. Der Outputwert des Reglers wird direkt als Stellwert für 
die 8bit PWM genutzt.
Der Regler soll alle 100ms aufgerufen werden.

Ist die Realisierung meines Reglers nun so korrekt?

hier mein vollständiger Sourcecode:

#define F_CPU 16000000UL

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>

#include "ds18b20.h"
#include "debug_master.h"
#include "statusled.h"


//###########################################################################################################
//Definiton Soll-Temperaturwert
//###########################################################################################################

#define temperatur_sollwert_eingabe            50
//#define temperatur_korrektur_offset            0



//###########################################################################################################
//Definiton PI-Regler Parameter
//###########################################################################################################

#define SCALING_FACTOR 128

#define KP          ((uint16_t)(1*SCALING_FACTOR))    //KP Eingabe bis 255 möglich
#define KI          ((uint16_t)(0*SCALING_FACTOR))    //KI Eingabe bis 255 möglich
#define TA          ((uint16_t)(0.1*SCALING_FACTOR))  //Abtastzeit 100ms

//##################################

#define PRELOAD_VALUE    131
#define TIME_INTERVAL    50

//##########################################################################################################


volatile uint8_t regler_flag;




void Timer1_PWM_init()
{
  //Set OC1B as output;
  DDRB|=(1<<PB3);
  
  //Set COM1B1 and COM1B0 --> OC1B cleared on compare match and set when TCNT1=01; Set PWM1B --> Enable PWM B
  TCCR1A=(1<<COM1B1)|(1<<PWM1B);
  
  //Set Prescaler 8, ergibt 7812,5 Hz bei F_CPU=16 Mhz
  TCCR1B=(1<<CS12);
  
}



uint8_t pi_regler(int16_t regelabweichung)
{
  int16_t p_factor,i_factor;
  
  int32_t p_anteil,i_anteil,pi_regler_output;
  
  static int16_t regelabweichung_summe=0;
  
  p_factor=KP;                //Format S(8,7)
  i_factor=(((int32_t)KI)*TA)/SCALING_FACTOR;        //Format S(8,7)
  
  
  regelabweichung=regelabweichung/8;          //Umwandlung Format S(11,4) zu S(14,1), da Sensor sowieso nur einen Wert mit 0,5 Grad Auflösung liefert
  
  //Bestimmung P-ANTEIL
  p_anteil=((int32_t)p_factor*regelabweichung)/2;        //Berechnung im Format S(24,7)
  
  //Bestimmung I-ANTEIL
  regelabweichung_summe+=regelabweichung;          //Berechnung im Format S(14,1)
  
  
  //Begrenzung I-Anteil
  if(regelabweichung_summe<0)
  {
    regelabweichung_summe=0;
  }
  
  if(regelabweichung_summe>(255*2))          //Regelabweichung Summe im Format S(14,1)
  {
    regelabweichung_summe=(255*2);
  }
  
  
  i_anteil=((int32_t)i_factor*regelabweichung_summe)/2;      //Berechnung im Format S(24,7)
  
  //Bestimmung RUECKGABEWERT
  pi_regler_output=(p_anteil+i_anteil)/SCALING_FACTOR;      //Berechnung im Format S(31)
  
  
  if(pi_regler_output>255)
  {
    pi_regler_output=255;
  }
  
  
  if(pi_regler_output<0)
  {
    pi_regler_output=0;
  }
  
  return (uint8_t) pi_regler_output;
  
}





//Preload Value von 131 und Count von 50 soll eine Gesamtverzögerung von 100ms ergeben
void Timer0_init()
{
  //setzen des Preload Value
  TCNT0=PRELOAD_VALUE;
  
  //Prescaler 256
  TCCR0|=(1<<CS02);
  
  //Enable Timer Overflow Interrupt
  TIMSK|=(1<<TOIE0);
  
}


ISR(TIMER0_OVF0_vect)
{
  TCNT0=PRELOAD_VALUE;
  
  static uint8_t i=0;
  
  i++;
  
  if(i==TIME_INTERVAL)
  {
    regler_flag=1;
    i=0;
  }
}


int main(void)
{
  //########################################################################################################
  //Variablen definieren
  //########################################################################################################

  uint8_t ds18b20_scratchpad[2];
  
  int16_t temperatur_istwert;
  int16_t temperatur_sollwert;
  int16_t temperatur_regeldifferenz;

  

  //DS18B20 Werte für 9bit Auflösung ins Scratchpad schreiben
  ds18b20_config_9bit();
  
  
  //Statusled initalisieren
  statusled_init();
  

  //Debug Ausgabe initalisieren  
  debug_master_init();
  

  //Timer0 für Erzeugung Abtastzeit initalisieren
  Timer0_init();
  

  //Timer1 für PWM Ausgabe initalisieren
  Timer1_PWM_init();
  

  //Interrupts freigeben
  sei();
  
  
  
  
  while(1)
  {
    if(regler_flag)
    {
      regler_flag=0; //PI Regler Flag zurücksetzen
      
      

      //Start der Temperaturmessung und anschließendes auslesen
      ds18b20_convert_and_readout(ds18b20_scratchpad,2);
      

      //Temperatur-Sollwert in 16bit Variable schreiben im Formate S(11,4)
      temperatur_sollwert=(temperatur_sollwert_eingabe*16);
      

      //Temperatur-Istwert in 16bit Variable schreiben, Format S(11,4)
      temperatur_istwert=(ds18b20_scratchpad[1]<<8)+ds18b20_scratchpad[0];
      

      //Berechnung Regeldifferenz in 16bit Variable schreiben, Format S(11,4)
      temperatur_regeldifferenz=temperatur_sollwert-temperatur_istwert;
      

      //PI-Regler
      OCR1B=pi_regler(temperatur_regeldifferenz);

    
    }
  }
}

[mr. mo (Gast)]

Meier schrieb:
> Bei einem KP von 1 (KI=0) kommt das ganze ins Schwingen. Könnte
> vielleicht der ein oder andere Reglungstechnik Profi hierzu was sagen?
> Bzw. mir einen Anhaltspunkt geben mit welchem KP ich Anfangs beginnen
> sollte?

Du hast ja immerhin schonmal eine ?Sprungantwort? von deinem Aufbau. Da 
gibt es zum Beispiel ein Tangentenverfahren um die einzelnen Parameter 
ermitteln zu können. Ausprobieren ist auch eine Möglichkeit. Auf der 
Roboternetz seite zum Thema Regelungstechnik wird dazu auch was erzählt, 
also wie man durch ausprobieren auf gute Werte für die einzelnen 
Parameter kommt.

http://www.rn-wissen.de/index.php/Regelungstechnik#Dimensionierung_des_Reglers

"Dimensionierung durch Probieren (Empirisches Einstellen)" ist genau das 
was du dir durchlesen solltest. Wo dein System eh schon ein wenig 
schwingt kannst auch mal schauen ob du auf ein brauchbares Ergebnis mit 
Hilfe von "Einstellung nach der Schwingungsmethode" kommst, wird dort 
ebenfalls recht gut erklärt.

[Morz Kerl (Gast)]

Mit etwas Voraussicht oder Glueck hat der Controller eine verfuegbare 
serielle Schnittstelle, die auch einen Treiber furt RS232 ode so 
angeflanscht hat. Dann braucht man nur noch ein kleines Protokoll, das 
erlaubt die Parameter zur Laufzeit zu verstellen.
Ueber die gleiche Schnittstelle kann man sich dann auch Werte von 
interesse geben lassen. Alternativ kann man sich einen 4/8 fach DAC 
anflanschen und die Werte ueber den DAC ausgeben, zum mit dem Scope 
zuschauen.
Ohne so einen Ansatz wird's schwierig.

[Meier (Gast)]

@ Morz Kerl

Hallo,

sowas ähnliches zumindest hab ich vorgesehen ;)

Die Werte oben sind direkt vom Controller ausgegeben worden (die in der 
angehängten Grafik). Die Regler Parameter ändere ich direkt über die ISP 
Schnittstelle.

Ich hab nur das Problem das mein System eigentlich bei jedem Wert von KP 
schwingt. Und ich weiss auch nicht so Recht wie ich jetzt weiter 
vorgehen soll... da ich eigentlich das Faustformelverfahren nutzen 
wollte :(

Desweitern wäre es mir zunächst einmal sehr wichtig ob mein 
PI-Controller Code so richtig realisiert ist insb. das mit dem Anti 
Windup..

[Uwe (Gast)]

Hi,
>DS18B20 und
>#define TA          ((uint16_t)(0.1*SCALING_FACTOR))  //Abtastzeit 100ms
passt so garnicht weil fast 1 Sekunde vergeht ehe du einen neuen Wert 
hast.
Solange KI=0 ist sollte aber nichts falsches rauskommen. Das dein Regler
aber ohne KI schon schwingt ist nicht ok, er sollte sich eigentlich 
abhängig von KP etws unterhald des Sollwertes einregeln.
Dein Ganzer Code sieht irgendwie recht komisch aus, aber es ist schon 
recht spät und ich acker das jetzt nicht durch.

Viel Erfolg, Uwe

[Meier (Gast)]

hi Uwe,

der DS18B20 ist auf 9bit konfiguriert und braucht zur messung daher max. 
93,75 ms...

Ich weiss echt wo das Problem liegen könnte, warum das ganz direkt 
anfängt zu schwingen... Von daher wäre ich echt sehr dankbar wenn noch 
jemand genauer drüber schauen könnte :(

Ratlos

[Karl H. (kbuchegg)]

Das hier

  if(regelabweichung_summe<0)
  {
    regelabweichung_summe=0;
  }
  
  if(regelabweichung_summe>(255*2))          //Regelabweichung Summe im Format S(14,1)
  {
    regelabweichung_summe=(255*2);
  }

erscheint mir nicht logisch.
Warum soll die Summe der Regelabweichungen nicht auch negativ werden 
können? Dein I-Regler kann auf die Art niemals in die negative Richtung 
korrigieren, sondern muss warten, bis der P-Anteil unterschwingt, so 
dass die Summe wieder positiv wird und der I-Anteil den restlichen 
Fehler ausregeln kann.

[Karl H. (kbuchegg)]

Deine willkürlichen *2, /2, /8  rufen bei mir da jetzt auch keine 
Begeisterungsstürme hervor.

    p_anteil=((int32_t)p_factor*regelabweichung)/2

Warum ist der Faktor '/2' nicht im p_faktor enthalten?

[fart (Gast)]

http://www.rn-wissen.de/index.php/Regelungstechnik
fart

[Meier (Gast)]

Danke für den Hinweis!

War mir irgendwie garnicht aufgefallen!

Im Moment hänge ich an dem Problem das mein System eigentlich immer 
schwingt ca. minimal +1 / -2.5 °C bei einem KI=0...

Woran kann das liegen?

Regelstrecke besteht aus meinem kleinen Heizungselement das in einer 
Hülse steckt. Der Temperatursensor ist außen an der Hülse angebracht.

Btw.: Ist die Erzeugung meiner Abtastzeit TA korrekt?

[Morz Kerl (Gast)]

WEnn's schwingt sind die Parameter noch zu hoch. Mach den I-Teil ganz 
weg. Dann den P Teil kleiner. Wenn's dann immer noch schwingt ist eine 
Verzoegerung drin. Dann nach Standard.

[Morz Kerl (Gast)]

Ich wuerd auf eine Verzoegerung tippen.Das kann man nur mit einem ganz 
kleinen I Teil wegmachen. Allenfalls mit vorwaerts Steuerung. Indem man 
die Umwelt parameter mitmisst.

[Karl H. (kbuchegg)]

Meier schrieb:
> Danke für den Hinweis!
>
> War mir irgendwie garnicht aufgefallen!
>
> Im Moment hänge ich an dem Problem das mein System eigentlich immer
> schwingt ca. minimal +1 / -2.5 °C bei einem KI=0...

lass dir halt mal die ganzen Werte ausgeben.
regelabweichung, p-Anteil, i-anteil, etc.

Wenn ein reiner P Regler schwingt (und sonst alles korrekt ist) dann ist 
das Kp zu groß.

> Regelstrecke besteht aus meinem kleinen Heizungselement das in einer
> Hülse steckt. Der Temperatursensor ist außen an der Hülse angebracht.

Also quälend langsame Regelstrecke.

[Meier (Gast)]

@Karl Heinz Buchegger

Wie kann ich eine Festkommaarithmetik den am besten bzw. am 
geschicktesten implementieren? So das ich nicht so oft bzw. willkürlich 
dividieren muss??

Es ging einfach darum das ich mir gemerkt hatte zuerst zu multiplizieren 
und anschließend erst zu dividieren...

[kukuk (Gast)]

warum 100ms...moechtest du Gluehdraht messen?
Temp_messungen sind traege Angelegenheiten !

Immer diese Eile !

[Meier (Gast)]

Hab gerade glaubig schonmal einen Fehler gefunden...

Kann es sein das das OCR1C nicht standardmässig mit 0xff initalisiert 
wird? Hat das nämlich irgendwo hier mal gelesen...

Oder is das von AVR zu AVR nochmal unterschiedlich? Studiere mal jetzt 
mal das Datenblatt...


Gruß

[Meier (Gast)]

Hallo erneut,

also der primäre Fehler lag tatsächlich an dem nicht gesetzten TOP Wert 
der PWM.... :(

Hab das ganze jetzt erneut laufen mit einem KP von 25.0 aufgezeichnet. 
(Siehe Anhang).
Sieht das ganze jetzt normal aus für einen reinen P-Regler? (KP ist wohl 
schon ein wenig zu hoch denk, daher die leichte Schwingung)

Ich möchte jetzt die Regelparameter nach der Schwingungsmethode von 
Nichols Ziegler bestimmen. Muss die hierbei zu ermittelnde kritische 
Schwingung genau mit gleicher Amplitude (bzw. symmetrisch) um den 
Sollwert schwingen?
Bzw. wann weiß ich das das jetzt die kritische Schwingung ist? (wenn 
sich danach die Amplitude der Schwingung aufschaukelt??)

Kann mir noch einer die Frage beantworten wie groß ich die Größen des 
Anti Wind-up wählen soll?


Hier kam die Aussage auf das mein Quellcode komisch aussieht. Bitte ein 
bisschen konkreter und mögliche Verbesserungsmöglichkeiten.

Ich hab das mit dem I-Anteil im negativen Bereichen jetzt noch 
angepasst. Hier mein derzeitiger Stand vom PI-Regler.

uint8_t pi_regler(int16_t regelabweichung)
{
  int16_t p_factor,i_factor;
  
  int32_t p_anteil,i_anteil,pi_regler_output;
  
  static int16_t regelabweichung_summe=0;
  
  p_factor=KP;                      //Format S(8,7)
  i_factor=(((int32_t)KI)*TA)/SCALING_FACTOR;        //Format S(8,7)
  
  
  regelabweichung=regelabweichung/8;            //Umwandlung Format S(11,4) zu S(14,1), da Sensor sowieso nur einen Wert mit 0,5 Grad Auflösung liefert
  
  //Bestimmung P-ANTEIL
  p_anteil=((int32_t)p_factor*regelabweichung)/2;      //Berechnung im Format S(24,7)
  
  //Bestimmung I-ANTEIL
  regelabweichung_summe+=regelabweichung;          //Berechnung im Format S(14,1)
  
  
  //Begrenzung I-Anteil
  if(regelabweichung_summe<(-255*2))            //Regelabweichung Summe im Format S(14,1)
  {
    regelabweichung_summe=(-255*2);
  }
  
  if(regelabweichung_summe>(255*2))            //Regelabweichung Summe im Format S(14,1)
  {
    regelabweichung_summe=(255*2);
  }
  
  
  i_anteil=((int32_t)i_factor*regelabweichung_summe)/2;  //Berechnung im Format S(24,7)
  
  //Bestimmung RUECKGABEWERT
  pi_regler_output=(p_anteil+i_anteil)/SCALING_FACTOR;  //Berechnung im Format S(31)
  
  
  if(pi_regler_output>255)
  {
    pi_regler_output=255;
  }
  
  
  if(pi_regler_output<0)
  {
    pi_regler_output=0;
  }
  
  return (uint8_t) pi_regler_output;
}

Danke für eure Hilfe

[Karl H. (kbuchegg)]

Meier schrieb:

> Ich möchte jetzt die Regelparameter nach der Schwingungsmethode von
> Nichols Ziegler bestimmen. Muss die hierbei zu ermittelnde kritische
> Schwingung genau mit gleicher Amplitude (bzw. symmetrisch) um den
> Sollwert schwingen?

Nein.
Denn ein reiner P-Regler erreicht den Sollwert nicht.
Erst mit einem kleine I-Anteil ist das dann der Fall.

> Kann mir noch einer die Frage beantworten wie groß ich die Größen des
> Anti Wind-up wählen soll?

Das sind alles Erfahrungswerte, die am jeweiligen Objekt bestimmt werden 
müssen.

> Hier kam die Aussage auf das mein Quellcode komisch aussieht. Bitte ein
> bisschen konkreter und mögliche Verbesserungsmöglichkeiten.

elends lange Variablennamen, wobei die Länge nichts zum Verständnis 
beiträgt. Dafür dann als Ausgleich keine Leerezeichen, die das Auge beim 
Lesen unterstützen würden einzelne Wörter zu erkennen. Dafür dann 
haufenweise sinnlose Kommentare.


Der Code sieht meiner Meinung nach extrem in die Länge gezogen aus. Der 
Anteil an unnützem White-Space ist übermässig hoch, ohne dass es was an 
der Übersicht bringt.


zb
>
>   //Bestimmung P-ANTEIL
>   p_anteil=((int32_t)p_factor*regelabweichung)/2;      //Berechnung im
> Format S(24,7)

No, na. Links vom = steht p_anteil. Wozu brauch ich da noch einen 
Kommentar "Bestimmung P-Anteil". Wenn da eine Zuweisung an die Variable 
p_anteil erfolgt, dann wird hier wohl nicht die aktuelle Temperatur 
gemessen werden.

Im Kommentar steht was vom "Format S(24,7)".
Nur leider ist im ganzen Programm kein einziger Hinweis darauf, was das 
überhaupt sein soll. Daher: Dieser Kommentar ist ein 0-Kommentar. Er 
erzählt mir nichts, was für das Verständnis relevant wäre.

uint8_t pi_regler(int16_t regelabweichung)
{
  int16_t p_factor,i_factor;
  
  int32_t p_anteil,i_anteil,pi_regler_output;
  
  static int16_t regelabweichung_summe=0;

Nach jeder Zeile eine Leerzeile einfügen bewirkt nur eines: Der Code 
wird in die Länge gezogen. Übersicht bringt das keine. Ganz im 
Gegenteil. Wenn ich beim Code-Lesen ständig hin und her scrollen muss, 
verliert man meist ständig den Faden.

[Karl H. (kbuchegg)]

void Timer1_PWM_init()
{
  //Set OC1B as output;
  DDRB|=(1<<PB3);
  
  //Set COM1B1 and COM1B0 --> OC1B cleared on compare match and set when TCNT1=01; Set PWM1B --> Enable PWM B
  TCCR1A=(1<<COM1B1)|(1<<PWM1B);
  
  //Set Prescaler 8, ergibt 7812,5 Hz bei F_CPU=16 Mhz
  TCCR1B=(1<<CS12);
  
}

Du darfst ruhig davon ausgehen, dass dein Leser ein wenig AVR 
Programmieren kann. Das PB3 am Port B der OC1B Pin ist, das weiß man 
nicht unbedingt auswendig, ist schon richtig. Aber das das Bitsetzen im 
DDR Register den Pin auf Ausgang schaltet, das weiß wohl jeder. Wenn du 
dir am Anfang der Funktion die angestrebte Konfiguration zusammenfasst, 
dann macht das auch nicht so den Eindruck von Zersplitterung

void Timer1_PWM_init()
{
  // PWM mit 7.8Khz   (F_CPU: 16Mhz, Prescaler: 8)
  //   8 Bit PWM am B-Kanal (Pin OC1B  (PORTB, PB3))
  //   "Clear on match" und "Set on Top"

  DDRB |= (1<<PB3);
  TCCR1A = (1<<COM1B1) | (1<<PWM1B);
  TCCR1B = (1<<CS12);
}

[Meier (Gast)]

Bzgl. der Schwingungsmethode von Nichols Ziegler:

Heisst das jetzt das ich solange KP erhöhe bis sich eine gleichförmige 
Schwingung ergibt? Unabhängig von deren Amplitude und die Lage um den 
Sollwert?

Gruß

[Meier (Gast)]

Und nochmal zurückkommend auf das Format S(24,7):

Ich dachte eigentlich das die Angabe bei Festkommaarithmetik mit U(x,y) 
für eine unsigned integer mit x Vorkommabits, y Nachkommabits und analog 
für signed integer S(x,y) eine Art Konvention ist.

Dem ist wohl nicht so?! Gibt es eine andere gängigere Angabe diesbzgl.?

Gruß

[Ina (Gast)]

Hat denn keiner eine Ahnung?! Stehe vor einem ähnlichen Problem und 
würde dieses gerne noch am Wochenende lösen. :)

[Purzel H. (hacky)]

Ina... was ist das Problem? Natuerlich haben wir eine Ahnung. Aber die 
Poster sollen auch etwas lernen, etwas selbst debuggen. Die Technologien 
wurden erklaert.

wo liegt dein Problem, das so schnell geloes werden muss.

[Carsten (Gast)]

Hallo,

das Anti-Windup sollt ja nur verhindern, dass deine Stellgröße ins 
unendliche wächst(Theorie). In der Praxis wird die Stellgröße durch die 
PWM begrenzt, ich glaube du hast da 8-bit. Dann sollte die Begrenzung 
bei max. Stellgröße 255 liegen. Für eine ausreichend gute Regelung kann 
man ruhig die volle Stellgröße fahren um den Idealfall den aperiodischen 
Grenzfall zu erreichen. Das ganze hat also nichts mit Erfahrungswerten 
zu tun. Z.B. kann ein Dead-Beat Regler in einen digitalen Regelschritt 
eine Temperaturstrecke ausregeln.

Um Faustformeln anwenden zu können musst du auf alle Fälle eine 
Sprungantwort auf die Stellgröße aufnehmen. Das kann so aussehen, dass 
du z.B. 100% Stellgröße auf den Heizstab gibst und die 
Temperaturerhöhung aufzeichnest. Das wird dann ein PT1 oder eher PT2 
Verhalten geben, da sollte aber nichts schwingen!

Wie sieht denn dein Regelalgorithmus aus?

Es sollte nach dieser Formel gerechnet werden

yk=yk-1 + kr (xdk - (1-t/tn) * xdk-1) wobei xdk der Istwer ist.

Das ist der Stellungalgorithmus, wobei yk der Stellwert ist.

[Meier (Gast)]

Hallo Carsten,

vielen Dank für deine Antwort!

Mein derzeit genutzter genutzter Code steht oben im Post vom
Datum: 28.09.2012 15:09.

Als Alogorithmus benutzte ich da: y=e*KP+KI*TA*e_summe (D-Anteil hab ich 
keinen)

Bzgl. dem Anti Wind-up heisst das jetzt das ich die Begrenzung von 
e_summme so einstellen soll das der alleine I-Anteil noch einen 
Vollauschlag der Stellgröße herbeiführen kann in der Begrenzung?

Sprich maximal Wert PWM 255 --> e_summe_max= +/- 255/(TA*KI) ??