PID Regler. Größen glätten

Moin,

ich hab mir einen kleinen PID Regler mittels Thermistor und 40W 12V Heizpatrone und Nextion Display gebaut.

Solltemperatur stelle ich via Poti ein. (Auf dem Bild in Blau)

Isttemp kommt vom Thermistor. (Auf dem Bild in Rot)

Dann hab ich noch die Reglerausgangsgröße. (Auf dem Bild in Gelb)

Die Reglerausgangsgröße 0-255 schießt ja ständig hin und her. Kann mir jemand sagen wie ich das ganze ein wenig Dämpfen kann?

Für den Thermistor nutze ich das Beispiel: How Easy Is It to Use a Thermistor?! | Arduino Project Hub

Vielen dank.

Bild

#define Kp 10        // Proportional
#define Ki 0.1       // Integrierer
#define Kd 1         // Differenzierer

// Thermistor

#define RT0 100000   // Thermistor Widerstand
#define B 3950      // K


#define VCC 4.47    // Versorungsspannung
#define R 100000    // Teilerwiderstand

//Variablen

float RT, VR, ln, TX, T0, VRT;

// --------------------------------


int temp1;
int thermistor1 = A1;

int error = 0;
int lastError = 0;
int regelDiff = 0;
int errorSum = 0;
int errorAlt = 0;
float Ta = 0.06;

int istTemp;
int sollTemp = 50;

int poti = A0;
int potiWert;

byte heizpatrone = 9;


const long interval1 = 100;
unsigned long previousMillis1 = 0;

byte incomingByte[6];

void setup()
{
  Serial.begin(9600);
  Serial3.begin(9600);
  T0 = 25 + 273.15;
}

void loop()
{
  potiWert = analogRead(poti);
  sollTemp = map(potiWert, 0, 1023, 0, 250);
  thermistor();

  unsigned long currentMillis1 = millis();
  if (currentMillis1 - previousMillis1 >= interval1)
  {
    previousMillis1 = currentMillis1;
    sendNum();
    Serial.print("Istwert: ");
    Serial.println(istTemp);
    Serial.print("Sollwert: ");
    Serial.println(sollTemp);
  }

  PID();
  wave();
}

void PID()
{
  if (sollTemp > 0)
  {
    error = sollTemp - istTemp;
    errorSum = errorSum + error;

    int regelDiff1 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff2 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff3 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff4 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff5 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt / Ta );

    errorAlt = error;

    regelDiff = (regelDiff1 + regelDiff2 + regelDiff3 + regelDiff4 + regelDiff5) / 5;



    if (regelDiff > 255) regelDiff = 255;
    if (regelDiff < 0) regelDiff = 0;

    analogWrite(heizpatrone, regelDiff);
  }
  else
  {
    regelDiff = 0;
    analogWrite(heizpatrone, regelDiff);
  }
}


void thermistor()
{
  VRT = analogRead(A1);
  VRT = (5.00 / 1023.00) * VRT;
  VR = VCC - VRT;
  RT = VRT / (VR / R);

  ln = log(RT / RT0);
  TX = (1 / ((ln / B) + (1 / T0)));

  TX = TX - 273.15;                 // Umwandlung in °C

  istTemp = TX;
}

Wenn ein PID-regler schwingt, sind die Parameter zu groß. Wie man sie einstellt, dafür gibt es Faustregeln und viel Theorie.

Es geht ja hier nicht um das einstellen der Parameter. Es geht um das rausfiltern von den Spitzen die man auf dem Bild erkennen kann.

Wenn dein Regler am Ausgang so (über) schwingt, dann sind die Parameter falsch.
(oder der Regler selber ist kaputt)

Fertig und aus!

Da den Ausgang dämpfen zu wollen ist sicherlich der falsche Weg.

Als Anregung:

int regelDiff5 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt / Ta );

Fehlt da nicht eine Klammer?

    int regelDiff1 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff2 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff3 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff4 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
    int regelDiff5 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;

    regelDiff = (regelDiff1 + regelDiff2 + regelDiff3 + regelDiff4 + regelDiff5) / 5;

Der tiefere Sinn dieser Berechnung will sich mir nicht erschließen.

  else
  {
    regelDiff = 0;
    analogWrite(heizpatrone, regelDiff);
  }

Das hat nach meinem Verständnis nichts mit PID zu tun.

combie:
Wenn dein Regler am Ausgang so (über) schwingt, dann sind die Parameter falsch.

Fertig und aus!

Da den Ausgang dämpfen zu wollen ist der falsche Weg.

Mir ist aufgefallen, dass diese Spitzen nur dann enstehen, wenn mein Thermistor Müll ausgibt, da sprint die Temperatur öfter mal um ein paar °C hin und her. Das haut beim Regler natürlich gleich spitzen rein. Das Problem will ich beheben.

agmue:
Als Anregung:

agmue:
Als Anregung:

int regelDiff5 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt / Ta );

Fehlt da nicht eine Klammer?

  else

{
   regelDiff = 0;
   analogWrite(heizpatrone, regelDiff);
 }



Das hat nach meinem Verständnis nichts mit PID zu tun.

Die Klammer ändert an der Rechnung nichts.

Zum letzten Abschnitt: Da geht es nur darum, dass der Regler nichts mehr machen kann, wenn das Poti auf 0 steht. Zur sicherheit.

Hallo,
ich habe keine Ahnung von PID-Reglern, weiß auch nicht wie sie funktionieren
oder was sie machen.
Ich weiß nur, das man mit so einem Ding etwas hochwichtig und noch genauer
sehr kompliziert einstellen kann. Das spielt aber alles keine Rolle…

Es ist und bleibt ja ein Regler. Dieser Regler gibt ja einen max. Wert aus,
mit dem Du arbeitest. Sagen wir einmal 100. Dein max. Wert mit dem Du
arbeitest ist 100.
Du kannst also alles was diesen Wert übersteigt abschneiden.
Das wäre ein Filter.
Dann könntest Du nur Werte anzeigen und verarbeiten die eben diese 100 nicht
überschreiten.
Das wäre ein Filter.
Du könntest auch in einer bestimmten Zeit "nur einmal" auswerten.
Also, in einer Sekunde nur einmal auswerten.
Das ist ein sehr guter Filter.
Du könntest auch aus einer bestimmten Anzahl von Messungen den Median
errechnen.
Das ist ein sehr guter Filter.

Optisch wäre das dann auf dem Nextion schön anzusehen. Sieht toll aus und
macht richtig etwas her.
Ist aber leider nicht das gemessene Ergebnis.

Wenn ich so einen Regler an meinem nicht mehr vorhandenen Nextion anschliessen
würde- und der liefert so einen Dreck- ja, dann…

würde ich mal diesen Regler angreifen und dafür Sorge tragen, das der genau
das liefert, was ich benötige.

Die beiden Jung´s, die hier von Schwingungen sprechen sind nicht ganz blöde. Ich
würde die ja mal fragen, wie man diese Schwingungen unterdrücken könnte.
Nur mal so…
Gruß und Spaß
Andreas

meister_q:
Mir ist aufgefallen, dass diese Spitzen nur dann enstehen, wenn mein Thermistor Müll ausgibt, da sprint die Temperatur öfter mal um ein paar °C hin und her. Das haut beim Regler natürlich gleich spitzen rein. Das Problem will ich beheben.

Du versuchst das Pferd von hinten aufzäumen!
Der Thermistor gibt Müll aus und du versuchst im Regler die Reaktion auf den Müll zu unterdrücken. Das ist der falsche Weg.
Du musst ergründen warum der Thermistor Müll ausgibt und das Problem an der Wurzel beseitigen.

Vielleicht kommt der Müll bei dem Thermistor schon daher dass du bei der Berechnung eine bunte Mischung aus float und int Variablen verwendest?
Mach die Berechnung mal durchgängig in float, dann sieht es vermutlich schon besser aus!

Gruß Peter

Außerdem ist das was du in PID() machst alles andere als ein PID-Regler. Darin fehlen vollkommen die rechenintensiven zeitlichen Komponenten für den integralen und differentialen Anteil.
Warum verwendest du nicht die PID-Library. Die ist wirklich gut.

so leid es mir tut, dein Code ist kein PID-Regler.

Kp * error Das ist soweit korrekt.
Ki * Ta * errorSum für das I-Glied summiert man nicht den Fehler aus, sondern den I-Anteil; und was ist Ta??
z.B. so: ITerm += Ki * error * T_PID ( der Zeitbezug ist wichtig, wenn der Regler nicht immer in gleichen Zeitabständen aufgerufen wird)
Kd * (error - errorAlt) / Ta ; Soweit korrekt, aber was ist Ta?? Und auch hier wäre ein Zeitbezug sinnvoll

int regelDiff1 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
int regelDiff2 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
int regelDiff3 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
int regelDiff4 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt) / Ta ;
int regelDiff5 = Kp * error + Ki * Ta * errorSum + Kd * (error - errorAlt / Ta );

5 mal das gleiche zu rechnen, zu addieren und wieder durch 5 zu teilen ist unsinnig.

Auf deinem Bild sieht das Signal des Thermistors aber gut aus. Wenn es dir zu nervös ist, dann must das Eingangssignal filtern.

Wenn dein PID läuft (wobei auch ich dir empfehle, nimm die PID lib), dann musst du sinnvolle parameter finden.

erst mal alle auf Null.
dann Kp langsam steigern, bis der Regler ein Überschwingen zeigt. Wieder etwas zurück.
das selbe dann mit Ki, aber sehr vorsichtig. Bei Heizungen reicht oft ein Ki von 0,001 schon aus.
Kd brauchst du bei einem System mit Heizung meist nicht, es sei denn du bekommst Störungen von aussen (Tür auf etc)

Nun, ich habe mich an dem PID Regler auf dieser Seite orientiert.

http://rn-wissen.de/wiki/index.php/Regelungstechnik

Dort ist ja der Software PID Regler abgebildet. Das Funktioniert auch soweit gut.

Was mir schmerzen bereitet sind diese Spitzen in der Messung, was dazu führt, dass der Regler immer so Ausschlägt.

Ich habe meinen Coed mal aktualisiert:

#define Kp 5        // Proportional
#define Ki 0.05       // Integrierer
#define Kd 0         // Differenzierer

// Thermistor

#define RT0 100000   // Thermistor Widerstand
#define B 3950      // K


#define VCC 4.47    // Versorungsspannung
#define R 100000    // Teilerwiderstand

//Variablen

float RT, VR, ln, TX, T0, VRT;

float VRTi[10];

// --------------------------------


int temp1;
int thermistor1 = A1;

float error = 0.00;
float lastError = 0.00;

int regelDiffInt = 0;
float regelDiff = 0.00;

float errorSum = 0.00;
float errorAlt = 0.00;
float Ta = 1;

int istTemp;
float istTempFloat = 0.00;
int sollTemp = 0;
float sollTempFloat = 0.00;

int poti = A0;
int potiWert;

byte heizpatrone = 9;


const long interval1 = 100;
unsigned long previousMillis1 = 0;

byte incomingByte[6];

void setup()
{
  Serial.begin(9600);
  Serial3.begin(9600);
  T0 = 25 + 273.15;
}

void loop()
{
  potiWert = analogRead(poti);
  sollTemp = map(potiWert, 0, 1023, 0, 250);
  sollTempFloat = sollTemp;
  thermistor();

  unsigned long currentMillis1 = millis();
  if (currentMillis1 - previousMillis1 >= interval1)
  {
    previousMillis1 = currentMillis1;
    sendNum();
    Serial.print("Istwert: ");
    Serial.println(istTemp);
    Serial.print("Sollwert: ");
    Serial.println(sollTemp);
  }

  PID();
  wave();
}

void PID()
{
  if (sollTemp > 0)
  {
    error = sollTempFloat - istTemp;
    errorSum = errorSum + error;

    regelDiff = ((Kp * error) + (Ki * Ta * errorSum) + Kd * (error - errorAlt)) / Ta ;

    errorAlt = error;

    if (regelDiff > 255) regelDiff = 255;
    if (regelDiff < 0) regelDiff = 0;

    analogWrite(heizpatrone, regelDiff);
  }
  else
  {
    regelDiff = 0;
    analogWrite(heizpatrone, regelDiff);
  }
}


void thermistor()
{
  for (int i = 0; i <= 5; i++)
  {
    VRTi[i] = analogRead(A1);
  }
  VRT = (VRTi[0] + VRTi[1] + VRTi[2] + VRTi[3] + VRTi[4]) / 5;
  VRT = (5.00 / 1023.00) * VRT;
  VR = VCC - VRT;
  RT = VRT / (VR / R);

  ln = log(RT / RT0);
  TX = (1 / ((ln / B) + (1 / T0)));

  TX = TX - 273.15;                 // Umwandlung in °C



  istTemp = TX;
  istTempFloat = istTemp;
}

Wenn die Temperatur-Messung verrauscht ist, und du nicht rauskriegst warum (das wäre besser), kannst du sie evtl. filtern. Entweder einfacher Software-Tiefpass, oder gar einen Kalman-Filter.

Erstmal den Kd-Anteil rausnehmen wie du es getan hast, ist auch ein Notbehelf, denn der reagiert am empfindlichsten auf solches Zappeln.

meister_q:
Zum letzten Abschnitt: Da geht es nur darum, dass der Regler nichts mehr machen kann, wenn das Poti auf 0 steht. Zur sicherheit.

Stimmt, sorry!

#define RT0 100000   // Thermistor Widerstand

#define R 100000    // Teilerwiderstand

Sind da je 100 kOhm gemeint? Dann dürfte das nach meiner Erinnerung die zulässigen Widerstandswerte für den AD-Wandler überschreiten. Da wird der Kondensator nicht zuverlässig geladen, was zu zappelnden Ergebnissen führt.

 istTemp = TX;
  istTempFloat = istTemp;

Du schmeißt die Stellen rechts vom Komma weg, warum?

Der AD-Wandler flattert von sich aus um mindestens ein Bit, das ist normal. Daher ist interessant, was das in °C ausmacht:

wert: 20 istTempFloat: 144.94
wert: 19 istTempFloat: 147.27
wert: 18 istTempFloat: 149.75
wert: 17 istTempFloat: 152.41

Nur ein flatterndes Bit macht schon 2,3°C aus. Dieser Wert ist nicht linear, hängt von der Temperatur ab.

Unglücklicherweise nutzt Du dann noch nicht mal den Float-Wert der Temperatur, s. o.

Die Temperaturabweichung wird mit Kp = 5 multipliziert. Ein flatterndes Bit führt damit zu einer Stellwertveränderung von 11,5.

Du merkst, die Umsetzung einer theoretisch ermittelten Formel auf einen µC ist nicht trivial. Möglicherweise kannst Du durch geschickte Wahl anderer Komponenten zu einem besseren Meßergebnis gelangen.

Hi

meister_q:

VRT = (5.00 / 1023.00) * VRT;

Spontan fällt mir auf, daß Du die 5V durch 1023 teilst - dort sind aber 1024 'Zwischenschritte' möglich, von 0 bis 1023 sind 1024 Schritte.

Welche Rolle Ta dort spielen soll, erschließt sich mir nicht - durch den Wert 1 fällt diese Variable aber eh raus.

Bin selber PID-mäßig nicht sonderlich bewandert, weshalb es Dir wohl nicht hilft, daß mir in Deinem Code keine größeren 'Hoppalas' auffallen.

MfG

@michael_x: Stimmt, den D-Anteil zu reduzieren, hat geholfen.

Bild

@agume:

Ja, ist beides 100k, besser mit einem geringeren Widerstand?

Ich nutze die Float to Int umwandlung nur um am Nextion mit ganzen Zahlen zu arbeiten. Gerechnet wird mit float.

Ja hast recht.. Das ist komplizierter als ich dachte. Aber die Library will ich nicht nutzen. Je weniger Library, desto besser :stuck_out_tongue:

@postmaster-ino:

also mal mit 1024 testen, statt 1023?

meister_q:
Aber die Library will ich nicht nutzen. Je weniger Library, desto besser :stuck_out_tongue:

Wenn jeder im Lauf der Entwicklung der Menschheit auf die Erkenntnisse seiner Vorgänger verzichtet hätte, wären wir heute noch nicht von den Bäumen runter.

In der Lage bist Du auch - noch auf dem Baum.

Baue es doch erst mal mit der Lib auf, um die Zusammenhänge auszuloten.
Wenn Du danach der Meinung bist, dass Du das besser als die Lib kannst, dann baue eine bessere Lib für alle.

Gruß Tommy

Du hast meiner Meinung nach zwei grundlegende Fehler in deinen Überlegungen:

a) Du fängst am falschen Ende an.

Versuch erst mal ein stabiles Temperatursignal zu bekommen.
am einfachsten, in dem du das Roh-signal filterst, zum Beispiel mit einem einfachen Tiefpassfilter.

float Val;
int Eingangswert,j;

void setup() {  
  Serial.begin(115200);
  Serial.print("IN\t"); Serial.print("OUT\t\n"); 
}

void loop() {    
  Serial.print(Eingangswert); Serial.print("\t"); 
  Filtern(Val, Eingangswert, 100);
  Serial.print(Val); Serial.print("\t\n"); 
  if (j++ > 10) Eingangswert=1;  // nach 10 Werten Sprung auf 1  
}


/*************************************************************************************************
** Funktion Filtern()  by GuntherB 2014                                          **
**************************************************************************************************
** Bildet einen Tiefpassfilter (RC-Glied) nach.                                     **
** FF = Filterfaktor;  Tau = FF * Aufruffrequenz                                    **
**              ( bzw: Tau = FF / Aufrufperiode)                                                **
**                                                                       **
**  Input: FiltVal der gefilterte Wert, NewVal der neue gelesene Wert; FF Filterfaktor          **
**  Output: FiltVal                                                                             **
**  genutzte Globale Variablen: keine                                                         **
**************************************************************************************************/
void Filtern(float &FiltVal, int NewVal, int FF){
  FiltVal= (FiltVal * (FF-1) + NewVal) / FF;  
}

den Filterfaktor muss du nach den pysikalischen Gegebenheiten auswählen. Wie schnell kann sich die Temperatur in deinem Aufbau tatsächlich ändern? Bei thermischen Systemen sind das meist eher Minuten. Wenn du also deinen Filter alle 100ms aufrufst und z.B. ein Tau von 60 min willst: FF = 60 / 0,1 = 600

b) dein PID läuft ohne Zeitbezug in der loop(). Du rechnest also ca.1000mal pro Sekunde deinen PID, deine Abweichung, stellst deinen Ausgang um, aber dein System hat überhaupt keine Möglichkeit, darauf zu reagieren, weil es viel langsamer ist.

Nimm den PID und auch die Signalmessung mit Filter mit in deine 100ms Zeitscheibe, in der du die Serielle Ausgabe machst. Regler (zumindest solche mit I, D, oder Tx-Gliedern) brauchen zwingend einen Zeitbezug, sonst funktioniert das nicht.

Und, dann, wie in meinem letzten Post schon beschrieben, langsam rantasten:
erst mal alle Parameter auf Null.
dann Kp langsam steigern, bis der Regler ein Überschwingen zeigt. Wieder etwas zurück.
das selbe dann mit Ki, aber sehr vorsichtig. Bei Heizungen reicht oft ein Ki von 0,001 schon aus.
Kd brauchst du bei einem System mit Heizung meist nicht, es sei denn du bekommst Störungen von aussen (Tür auf etc)

Wenn dir das zu lange dauert (ich kenne dein System nicht) kannst du auch die Sprungantwort aufnehmen, und nach dem Faustformelverfahren von Ziegler und Nichols deine Regelparameter ermitteln.

meister_q:
Ja, ist beides 100k, besser mit einem geringeren Widerstand?

Wenn möglich, ja. Wobei Du Dir R0 nicht aussuchen kannst, da eine Eigenschaft des Thermistors. Kannst Du dafür ein Datenblatt verlinken? Das Beispiel verwendet 10 kOhm, das wäre besser.

meister_q:
Ich nutze die Float to Int umwandlung nur um am Nextion mit ganzen Zahlen zu arbeiten. Gerechnet wird mit float.

Das möchtest Du, tust es an der von mir widergegebenen Stelle aber nicht: float -> int -> float führt zwar formal zu float, die Zahl ist aber abgeschnitten. Beispiel: 147.27 -> 147 -> 147.00

meister_q:
Aber die Library will ich nicht nutzen.

Habe ich auch nicht geschrieben. Du könntest sie aber zu Vergleichszwecken heranziehen. Wenn Dein Konstrukt und die Bibliothek gleiche Ergebnisse liefern, schmeiß die Bibliothek raus :slight_smile:

meister_q:
Das ist komplizierter als ich dachte.

Und macht daher umso mehr Freude, stimmt's?

guntherb:
Du hast meiner Meinung nach zwei grundlegende Fehler in deinen Überlegungen:

a) Du fängst am falschen Ende an.

Versuch erst mal ein stabiles Temperatursignal zu bekommen.
am einfachsten, in dem du das Roh-signal filterst, zum Beispiel mit einem einfachen Tiefpassfilter.

b) dein PID läuft ohne Zeitbezug in der loop(). Du rechnest also ca.1000mal pro Sekunde deinen PID, deine Abweichung, stellst deinen Ausgang um, aber dein System hat überhaupt keine Möglichkeit, darauf zu reagieren, weil es viel langsamer ist.

Nimm den PID und auch die Signalmessung mit Filter mit in deine 100ms Zeitscheibe, in der du die Serielle Ausgabe machst. Regler (zumindest solche mit I, D, oder Tx-Gliedern) brauchen zwingend einen Zeitbezug, sonst funktioniert das nicht.

Und, dann, wie in meinem letzten Post schon beschrieben, langsam rantasten:
erst mal alle Parameter auf Null.
dann Kp langsam steigern, bis der Regler ein Überschwingen zeigt. Wieder etwas zurück.
das selbe dann mit Ki, aber sehr vorsichtig. Bei Heizungen reicht oft ein Ki von 0,001 schon aus.
Kd brauchst du bei einem System mit Heizung meist nicht, es sei denn du bekommst Störungen von aussen (Tür auf etc)

Wenn dir das zu lange dauert (ich kenne dein System nicht) kannst du auch die Sprungantwort aufnehmen, und nach dem Faustformelverfahren von Ziegler und Nichols deine Regelparameter ermitteln.

Danke, ich habe ja den Temperaturwert schon stabiler bekommen, indem ich u.A. einen Keramikondenstaor zwischen Pin und GND gemacht habe, zusätzlich habe ich "denke ich", die Variablen auf Float geändert. Außerdem habe ich den Faktor von Ta auf 2 anstatt 0.irgendwas gestellt. Das ganze sah dann schon etwas schöner aus, die Spitzen treten kaum noch auf. Aber wenn sie auftreten, sieht man die sofortige gegenreaktion vom Regler. Den von dir geposteten Filter muss ich noch einbauen. Siehe Bild1

Bild1

Sobald ich den Regler jetzt hochdrehe, steigt die Flanke schön an, flacht aber nicht stark genug ab, bevor Ist über Soll schießt, regelt sich dann aber schön ein. Wie man auf Bild2 erkennen kann.

Bild2

@agume:

Ich würde gerne das Datenblatt anheften, wirklich. Aber du weisst sicher genau wie ich, dass du in China keine Datenblätter bekommst. Ich kann nur sagen, dass es ein 100k NTC 3950 ist. Den Teilerwiderstand könnte ich natürlich Problemlos auf 10k minimieren.

Zur Library: Ich weiss das ihr das nicht hören wollt, aber ich will die so ungern nutzen.. Aber ich versuche mich mal dran, sobald es die Zeit zulässt.

Zum letzten:

Natürlich, wenn es einfach ist, macht es ja keinen Spass.

Ich mache aktuell meinen Techniker in Automatisierungstechnik. PID ist mir vertraut. Parametrierung nicht so sehr, Software PID Regler auch nicht. Allerdings sind mir auch nur die "einfachen" Regler von Siemens und Phoenix als Funktionsbaustein bekannt. Das ist ja eine ganz andere Geschichte.

Aber du weisst sicher genau wie ich, dass du in China keine Datenblätter bekommst.

Das gilt vielleicht für euch....

sieht man die sofortige gegenreaktion vom Regler

Grundregel: Anfänger stellen Regler immer zu heftig ein. :wink:

Hat dein Eigenbau - PID inzwischen eine vernünftige Zeitbasis ?
Wie schnell ist deine zu regelnde Strecke überhaupt. ( Wie lang muss die Heizung EIN sein, um eine Temperaturänderung von 10 °C zu erreichen, wie lang muss sie aus sein, um 10 °C weniger zu messen ?

graph.JPG
Dein Bild 2 ist ja schon ganz hübsch, was sieht man denn darauf?
Und was sind das für Spitzen in der gelben und roten Kurve?

graph.JPG