Hallo liebe Mikrocontroller Freunde,
ich habe momentan ein kleines Problem. Ich möchte gerne einen PI-Regler
für eine temperaturabhängige Lüftersteuerung umsetzen.
Leider scheitert es bei mir am Verständnis.
Mein Programmcode ist in verschiedene Tasks aufgebaut und der Task für
den Regler wird jede 0,5s aufgerufen. Woher weiß ich ob die Zeit passend
für meinen Pi-Regler ist bzw. muss ich zudem noch ein Ta in meinem
Regler definieren?
Das ist mein aktueller Code: Ist der Ansatz richtig oder habe ich
grundsätzlich Denkfehler im Code?
UINT16 PWMGetDuty()
{
float kp= 3.2; //Proportionalfaktor vom P-Teil
float ki= 2.6; //Integrationsfaktor vom I-Teil
UINT16 static StartBedingung= 0;
float static OutInt= 0; //Integralteil des Reglers
if (StartBedingung < 30) //15s Ausführung der Bedingung
{
StartBedingung += 1;
dutyCycle= 100; //Lüfter mit 100% ansteuern, danach
Aktivierung PI-Regler
}
else
{
error= (OutletTemperature - InTakeTemperature);
int x= 1;
switch (x)
{
case 1: if (OutletTemperature > InTakeTemperature&&
OutletTemperature < TempMax)
{
OutInt= OutInt +(ki * error);
OutProp= (kp * error);
}
dutyCycle= (OutProp + OutInt);
if (dutyCycle > 100)
{
OutInt= OutInt -(ki * error);
dutyCycle= 100;
}
break;
case 2: if (OutletTemperature < InTakeTemperature)
{
OutInt -= ki * error;
OutProp= (kp * error);
}
if(OutInt < 0)
{ OutInt= 0; }
dutyCycle= (OutProp + OutInt);
break;
case 3: if (dutyCycle > 100 || OutletTemperature >= TempMax)
{ dutyCycle= 100; }
break;
case 4: if (dutyCycle < 15)
{ dutyCycle= 15; }
break;
}
}
OCR3A= (dutyCycle*255)/100;
return dutyCycle;
}
Ich bin fürjede Hilfe dankbar.
> Woher weiß ich ob die Zeit passend für meinen Pi-Regler ist bzw. > muss ich zudem noch ein Ta in meinem Regler definieren? Die Theorie hinter deinem Regler welche du ja verwenden willst um z.B die Parameter festzulegen geht davon aus das dein regler analog ist. Wenn du nun abtastest dann solltest du das so haeufig tun das du quasi analog bist. Also z.B 10x schneller als die hoechste Frequenz in deinem System. Wenn du zweifel hast dann schneller. Vergleich das damit wie schnell ein Oszi sein muss um ein Signal bestimmter Frequenz darzustellen. Olaf
Ich habe mir zwar Deinen Programmentwurf nicht im Detail angesehen (zuviel englisch), würde Dir aber vorschlagen, mal nach der Einstellmethode von Ziegler und Nichols zu suchen (Wiki)
Hey erstmal vielen Dank für die schnellen Antworten. Die Parameter habe ich bereits über Ziegler Nichols bestimmt. Ich habe den Lüfter als PT2-Glied mit Simulink simuliert und die Sprungantwort bestimmt. Daraus dann die Parameter für einen PI-Regler entnommen. Der Lüfter wird mit einer Frequenz von ca. 7 kHz angesteuert. Mir ist jetzt aber nicht klar ob ich in meinem Programmcode noch die Abtastzeit Ta miteinfügen muss. Oder diese durch den Aufruf pro 0,5s entfällt.
Wolle G. schrieb: > ... (zuviel englisch) ... Viel schlimmer ist noch die Formatierung. In C Code Tags wäre der Code schon deutlich besser lesbar, also
1 | [c]<Code>[/c] |
z.B.
1 | if (StartBedingung < 30) //15s Ausführung der Bedingung |
2 | {
|
3 | StartBedingung += 1; |
4 | dutyCycle= 100; //Lüfter mit 100% ansteuern, danach Aktivierung PI-Regler |
5 | }
|
Mal ganz blöd nachgefragt von mir: Wie hast du den Regler diskretisiert? Spätestens da kommt deine Abtastzeit in der Gleichung vor. Für gewöhnlich wird nach Tustin (bilinear) diskretisiert. Gruß,
Ich habe das wendetangentenverfahren angewandt und aus dem Diagramm mein Tu, Tg und Ks ausgelesen. Danach mit Ziegler Nichols die Werte bestimmt
Oliver H. schrieb: > Ich habe das wendetangentenverfahren angewandt und aus dem > Diagramm mein Tu, Tg und Ks ausgelesen. Danach mit Ziegler Nichols die > Werte bestimmt Das ist deine analoge Regelung. Diese musst du aber diskretisieren, weil du nun eine digitale Regelung hast. Schreib mal die Gleichung für deine analoge PI Regelung auf ein Blatt Papier und lies dich in die bilineare Transformation ein. Probiere, diese auf deinen PI Regler anzuwenden und du hast deine Gleichung für den digitalen Regler, den du in deinen uC programmierst. Gruß,
Float ? Eine schlechte Idee. Integer genuegt vollkommen. Speziell weil die Resultate eher bescheiden sein duerfen. Ich bau Temperaturregler mit Int32, welche allerdings ein Tausendstel Grad aufloesen. Nicht so genau sind, aber aufloesen.
Ich wuerde mal mit einer Steuerung beginnen. Also das Stellglied proportional zur Differenztemperatur zwischen Innen- und Aussentemperatur
Also, das mit der Auflösung verstehe ich nicht ganz. Ist denn der Gedankengang grundsätzlich richtig. Ich erstelle meinen programmierten PI-Regler. Danach bestimme ich mein Kp und Ki. Ist der Regler grundsätzlich richtig programmiert, sollte die Regelung funktionieren oder? Jetzt ist aber zusätzlich die Frage, welche Rolle spielt es wie oft ich die Funktion aufrufe, momentan jede 0,5s. Und macht es Sinn den I-Teil an bestimmten Stellen runterzählen zu lassen oder nur einfrieren damit der Wert nicht zu groß wird? Ich stelle mir das in etwa so vor: Wenn Sollwert = Istwert dann ITeil runterintegrieren. Wenn nicht wieder auf integrieren. Und danke für den Hinweis Forist, ich werde den Code übersichtlicher gestalten.
> Ich erstelle meinen programmierten PI-Regler. Danach bestimme ich mein > Kp und Ki. Ist der Regler grundsätzlich richtig programmiert, sollte die > Regelung funktionieren oder? Ein analoger Regler mit Operationsverstaerkern schon. > Jetzt ist aber zusätzlich die Frage, welche Rolle spielt es wie oft ich > die Funktion aufrufe, momentan jede 0,5s. Schreibt deine Source nochmal neu, aber so das man ihn lesen kann. So einen kruden Mist will sich keiner anschauen. Auch du selber nicht! Und dann schausst du ihn dir selber noch mal an. Und dann fragst du dich, immerhin hast du es ja programmiert und nicht von anderen Internetdoedeln abgeschrieben, was macht eigentlich dein Programm. Vor allem was machen deine Funktionen mit ihren Daten wenn sie verschieden haeufig aufgerufen werden. Dann sollte dir sofort auffallen das da andere Ergebnisse rauskommen weil du oefters addierst/integrierst. Die Abtasthaeufigkeit gewichtet die Regelparameter. > Und macht es Sinn den I-Teil an bestimmten Stellen runterzählen zu > lassen oder nur einfrieren damit der Wert nicht zu groß wird? Versuche das von der anlogen Seite aus zu denken. Ein Integrierer mit Operationsverstaerker wird beliebige Ausgangspannungen in Abhaengigkeit seiner Bauteile, also des Ki annehmen. Aber er wird niemals eine Spannung ausserhalb der Betriebsspannung ausgeben koennen. Letzteres solltest du in der Software auch implementieren. Machst du da nicht verhaelt sich der Regler an seinen Grenzen ueberaschend. .-) Noch was... Benutze zu Anfang solange du noch nicht genug Ahnung hast ruhig weiter float oder sogar double. Heutige Mikrocontroller sind schneller als Opas MCS48! Wenn du dann alles laufen hast dann kannst du danach alles auf Integer umstellen. Das ist ein weiterer durchaus sinnvoller Prozess den man drauf haben sollte! Aber als Anfaenger macht er dir das Leben schwer weil du vorher wissen muesstest mit welchen Wertebereich du arbeiten willst. Olaf
Vielen Dank für die ausführliche Antwort! Ich werde das Programm nochmal umstrukturieren. > Vor > allem was machen deine Funktionen mit ihren Daten wenn sie verschieden > haeufig aufgerufen werden. Dann sollte dir sofort auffallen das da > andere Ergebnisse rauskommen weil du oefters addierst/integrierst. Was meinst du damit genau? Der Aufruf ist doch trotzdem jede halbe Sekunde. Und wenn die Temperatur wieder sinkt, fällt auch der error kleiner aus. Zudem will ich eine Abfrage implementieren, der meinen I-Teil runterzählt sobald er nahe genaug an der Solltemperatur ist. Und nochmal ne Frage für mein Verständnis. Würde es eine Rolle für meine Stabilität spielen, wenn der Regler nur jede Sekunde aufgerufen wird? Nach meinem momentanem Verständnis nicht. Also wenn ich kp und ki richtig bzw. passend wähle spielt die Aufrufzeit von 0,5s, 1s oder 2s keine so wichtige Rolle oder? Außer natürlich die Temperatur würde rasant ansteigen.
@ Oliver Ich schlage vor, Du machst mal folgendes Gedankenexperiment: Der Regler reagiert relativ langsam auf Veränderungen. D.h. unter Umständen, dass die Abweichung Zeit hat, grösser zu werden, ehe der Regler reagiert. Richtig? Daraus folgt, dass je nach Situation, die Regelabweichung größer werden kann, als Du zulassen möchtest. Es mag hilfreich sein, einmal die Sprungantwort und die Abtastrate gedanklich in Beziehung zu setzen. Wie hängt das eine mit dem anderen zusammen? ---- Zu der Variablenfrage, die mir auf einem Mißverständnis auf Deiner Seite zu beruhen scheint. Versuche bitte, so genau wie möglich, zu erklären: 1. wodurch sich bei Deinem gegenwärtigen Programm die Abtastrate bzw. die Aufruffrequenz der PI-Berechnung ergibt 2. ob Du bei Deinem bisherigen Programm eine bestimmte Abtastrate beabsichtigt hast und wie Du das erreicht hast Ich vermute, dass sich für Dich aus Deinen Antworten auf diese beiden Fragen auch die Antwort auf Deine hier gepostete Frage ergibt.
@ Oliver Übrigens kannst Du doch Varianten mit Simulink simulieren. Das müsste eigentliche einige Fragen beantworten, meine ich.
Angehängte Dateien:
-
PI-Regler_Sprung.png
65 KB
Ich verstehe die Abtastrate in der Programmierung einfach nicht..Ich rufe meine Funktion jede 0,5s auf und lass meinen PI-Regler rechnen. Mehr Zeitkonstanten sind momentan nicht vorhanden. Reicht das nicht aus? Der Regler reagiert doch eher relativ schnell im Verhältnis zu der Temperatur, diese ändert sich ja normalerweise nicht schlagartig. In Simulink habe ich simuliert. Aber wie kann ich daraus was passendes deuten für meine Programmierung. Vllt denk ich auch zu kompliziert? Ich habe mal als Ahang mein Simulinkgraphen angehängt.
Ups..das ist dreimal das gleiche Bild sollte nur einmal drinnen sein.
Oliver H. schrieb: > Ich verstehe die Abtastrate in der Programmierung einfach nicht..Ich > rufe meine Funktion jede 0,5s auf und lass meinen PI-Regler rechnen. > Mehr Zeitkonstanten sind momentan nicht vorhanden. Reicht das nicht aus? Was meinst Du genau mit "die Abtastrate in der Programmierung"? Erkläre das mal bitte. Deine Frage hat doch so gelautet: "Woher weiß ich ob die Zeit passend für meinen Pi-Regler ist ..." Die Abtastzeit ergibt sich aus der Sprungantwort (dem Frequenzgang) des Modells und, wie ich oben schrieb, aus der gewünschten maximalen Regelabweichung. "bzw. muss ich zudem noch ein Ta in meinem Regler definieren?" Ich glaube, Du stellst die Frage möglicherweise auf die falsche Weise. In der Regel wirst Du Deinen uC so programmieren, dass die Wiederholrate Deinem berechneten Ta entspricht. Du wirst also z.B. den Takt eines Timers festlegen. Deine Frage liest sich (für mich wenigstens) aber so, als ginge es Dir darum ob der Wert Ta in Deinem Programm ausdrücklich hingeschrieben werden muss; etwa als Konstante oder Variable. Das ist aber völlig gleichgültig, solange sich nur eben diese Ta ergibt. > Der Regler reagiert doch eher relativ schnell im Verhältnis zu der > Temperatur, diese ändert sich ja normalerweise nicht schlagartig. Du hast das doch modelliert, sagst Du. Nochmal: Die Abtastzeit ergibt sich aus der Sprungantwort > In Simulink habe ich simuliert. Aber wie kann ich daraus was passendes > deuten für meine Programmierung. Vllt denk ich auch zu kompliziert? Hast Du doch schon getan und daraus den proportionalen und integralen Anteil bestimmt. Richtig? > Ich habe mal als Ahang mein Simulinkgraphen angehängt. Ich bin in der Regelungstechnik nicht wirklich absolut sattelfest, aber: Unter der Sprungantwort (der Regelstrecke) versteht man meiner Kenntnis nach, die Reaktion des Systems auf die Änderung des Faktors, dessen Wirkung durch Regelung aufgehoben werden soll; also der Stellgrösse. Hingegen nicht die Reaktion auf Änderung der Sollgrösse (aka Führungsgrösse). Dein Diagramm sieht aber so aus, als wenn Du letzteres angenommen hast.
Oliver H. schrieb: > Ich habe den Lüfter als PT2-Glied mit Simulink simuliert Dann kennst du doch die Zeitkonstante oder kannst sie zumindest aus dem simulierten Diagramm ablesen. Die Abtastperiode sollte dann 10mal so kurz sein, wie die Zeitkonstante, um noch quasikontinuierlich unterwegs zu sein. "Nach Ablauf einer Zeit von ca. 3 Zeitkonstanten hat das Ausgangssignal ca. 95 % der Größe des Eingangssignals" https://de.wikipedia.org/wiki/Zeitkonstante > Aufruf pro 0,5s entfällt. Die Zeitkonstante des Regelsystems müsste also größer gleich 5s sein.
Nachtrag: Aus deinem Diagramm sieht man, dass der Lüfter eine Zeitkonstante von unter 1s hat. ABER: Es geht dir wenn ich das richtig verstanden habe um die Temperaturregelung und nicht um die Lüfterdrehzahl (die ungeregelt ist?)? Das Diagramm hilft in dem Fall nicht weiter.
Möchtest du die Ausgangstemperatur oder die Drehzahl des Lüfters regeln? Wenn du die Ausgangstemperatur regeln willst brauchst du die Sprungantwort der Ausgangstemperatur. Diese kannst du mit dem MC messen. Wähle eine konstante Abtastzeit ta von z.B. 1s und nimm die Werte der Ausgangstemperatur auf. Jetzt gibst du einen Sprung auf dein Stellglied (Lüfter) von 0% auf z.B. 50% oder auch 100%. Die Ausgangstemperatur wird jetzt vermutlich mit einer e-Funktion abfallen (PT1 - Strecke). Dein Regler muss jetzt etwa 10 mal schneller sein als die Zeitkonstante der PT1-Strecke. Danach gibst du einen negativen Sprung auf die Regelstrecke, d.h. du änderst den PWM-Wert sprungförmig von 100% auf z.B. 50% oder auch 0%. Der Verlauf der Ausgangstemperatur ist die negative Sprungantwort. Sie müsste auch einem PT1-Verlauf folgen. Die Sprungantworten könntest du mal hier reinstellen.
Also ich habe mich wohl undeutlich ausgedrückt. Ich möchte die Drehzahl des Lüfters regeln und nicht die Temperatur. Nun möchte ich wissen ob die zeit beim Aufruf der Regelung eine Rolle spielt. Momentan habe ich den PI-Regler mit meinem selbst bestimmten ki und kp aus der Sprungantwort programmiert. Spielt es aber hierbei eine Rolle wie oft der PI-Regler aufgerufen wird? Maxe: Du hast etwas von 5s Sekunden geschrieben, sollte meine Funktion bloß alle 5 Sekunden aufgerufen werden? Mir fehlt es momentan am Verständnis ob die Regelung instabil wird durch öfteren Aufruf der programmierten Regelung oder ob das keine Rolle spielt..
Oliver H. schrieb: > Also ich habe mich wohl undeutlich ausgedrückt. Ich möchte die Drehzahl > des Lüfters regeln und nicht die Temperatur. Das halte ich für sinnlos, es sei denn Du kannst darlegen, inwiefern die Temperatur in Bezug auf die Drehzahl eine Störgrösse ist. Bei im Haushalt möglichen Dimensionen von Lüftern halte ich das für unwahrscheinlich; zumindest würde man Lüfter so deutlich überdimensionieren, dass man evtl. Lagertemperaturen und deren Maßveränderung und damit die Drehzahl nicht ausregeln muss. Vielleicht beschreibst Du einmal die Ausgangssituation und das Ziel. > Nun möchte ich wissen ob die zeit beim Aufruf der Regelung eine Rolle > spielt. Momentan habe ich den PI-Regler mit meinem selbst bestimmten ki > und kp aus der Sprungantwort programmiert. > > Spielt es aber hierbei eine Rolle wie oft der PI-Regler aufgerufen wird? An sich sollte die Antwort auf meine Frage, zu der Antwort auf Deine Frage hinführen. > [...]
Oliver H. schrieb: > error= (OutletTemperature - InTakeTemperature); Das sieht mir aber eher nach einer regelung der Temperatur aus. Wie wird der Lüfter angesteuert? Wenns um die Lüftersteuerung geht: bei einer abgelesenen Zeitkonstante von etwa 0,8s müsste deine Abtastperiode 10 mal so schnell sein, oder schneller! Also höchstens 0,08s. Schneller geht immer, d.h. kürzere Zeiten sind nicht schädlich, z.B. alle 0,05s oder 0,01s, nur langsamere gehen nicht. Die Grenze ist natürlich nicht hart, kann auch drüber noch funktionieren. Die Abtastzeit muss gegebenenfalls mit in der Reglerstruktur berücksichtigt werden, beim I-Anteil definitiv.
Oliver H. schrieb: > OutInt= OutInt +(ki * error); > OutProp= (kp * error); Nachtrag: Hier arbeitet ja dein Integrator. Der muss aber die Abtastperiode berücksichtigen, sonst stimmt er nicht. Mit Abtastperiode T_Abtast (in Sekunden): OutInt= OutInt +(ki * error)*T_Abtast/1s; OutProp= (kp * error);
>Abtastperiode berücksichtigen, sonst stimmt er nicht. >Mit Abtastperiode T_Abtast (in Sekunden): Und wie bestimme ich die? >OutInt= OutInt +(ki * error)*T_Abtast/1s Was gebe ich für T_Abtast an?
Allenfalls wuerde sich auch einmal eine simulation auf einem PC lohnen. Dabei liessen sich alle werte zu allen Zeiten visualisieren...
Oliver H. schrieb: > Und wie bestimme ich die? > Was gebe ich für T_Abtast an? Das ist die Zeit zwischen jedem Aufruf deiner Regelung. Jetzt 0,5s. Was für die Drehzahlregelung zu wenig ist. Der Integrator addiert in jedem Schritt den Fehler auf. Tastest du 1000 Mal pro Sekunde ab, darf jedes Mal nur ein 1000stel des aktuelle Fehlers addiert werden, sonst geht der Integrator ja sofort durch die Decke. Insgesamt wird dann der fehler genau einmal pro Sekunde addiert, unabhängig von der Abtastrate. Deinen Faktor ki musst du dann nur noch auf die Basis "Sekunde" beziehen.
Also Maxe das was du jetzt gerade beschreibst ist genau mein Verständnisproblem. Die Abtastung von z. B. 1000 ist die von meiner Frequnz abhängig? Das bedeutet das mein Integrator momentan deutlich zu hoch ist, seh ich das richtig? wie kann ich dann mein ki auf die Basis Sekunde beziehen?? Hängt das dann demnach mit der Abtastung zusammen?
Also prinzipiell sind die Reglerparameter von der Abtastrate formal unabhängig, deswegen ist ja die Skalierung des integrierten Fehlers, wie ich sie ergänzt habe, notwendig. Bzgl. der Einheiten kommt es darauf an, wie du die Regelparameter bestimmst. float kp= 3.2; //Proportionalfaktor vom P-Teil float ki= 2.6; //Integrationsfaktor vom I-Teil Erfolgt die Berechnung mittels Polvorgabe, d.h. über die Zeitkonstante, dann ergibt sich die Einheit des Integrationsfaktors aus der Einheit der Zeitkonstanten, hier z.B. in Sekunden. Du hast von Ziegler-Nichols geschrieben, die Werte werden ja sowieso nicht analytisch berechnet, die Zeitbasis ist also egal, muss nur einmal festgelegt werden. Die Reglerparameter variieren dann halt je nach gewählter Zeitbasis. Ich würde eben die Sekunde vorschlagen. Ohne Skalierung geht es mit Ziegler-Nichols auch, dann ist der Integrationsfaktor ki aber abhängig von deiner Abtastrate (also von deinen 0,5s), das wäre murks und entspricht nicht den Konventionen.
Oliver H. schrieb: > ich habe momentan ein kleines Problem. Ich möchte gerne einen PI-Regler > für eine temperaturabhängige Lüftersteuerung umsetzen. Hier zeigt sich das im Forum schon häufig angesprochene Problem der unzureichenden Beschreibung der Anwendung. z.B. welche Temperatur soll geregelt, womit wird die Temperatur gemessen, wozu dient das Ganze usw. Wenn man als Helfender genau weiß, um was es sich handelt, kann man konkrete Antworten geben, ohne nach bestimmten Details erst nachzufragen. Siehe oben, z.B. 29.03.2020 12:50
Also ich habe es glaub ich fast verstanden. Tut mir leid das ich mich da gerade etwas blöd anstelle.. >Du hast von Ziegler-Nichols geschrieben, die Werte werden ja sowieso >nicht analytisch berechnet, die Zeitbasis ist also egal, muss nur einmal >festgelegt werden. Welche Zeit muss ich denn nun genau festlegen? Anhand von welchem Verhältnis ich denn die Zeitangabe fest?
Oliver H. schrieb: > Welche Zeit muss ich denn nun genau festlegen? Anhand von welchem > Verhältnis ich denn die Zeitangabe fest? OutInt= OutInt +(ki * error)*T_Abtast/1s; Wenn du diese Formel verwendest, ist deine Zeitbasis die 1s (eine Sekunde). T_Abtast musst du dann also auch mit der Einheit Sekunde einsetzen. Also eigentlich nichts besonderes.
Also ich stell mich vermutlich gerade sehr doof an, aber kann ich dann für T_Abtast "einfach" 0,5s einsetzen und gut ist?
> Also ich habe mich wohl undeutlich ausgedrückt. Ich möchte die Drehzahl > des Lüfters regeln und nicht die Temperatur. Wenn du die Drehzahl regeln willst, musst du auch die Drehzahl messen und nicht die Temperatur. Aus deinem Plot ganz oben sieht man in der Sprungantwort des Lüfters, dass nach 1,2s 63% der Drehzahl erreicht werden. das ist die Zeitkonstante deiner Regelstrecke. Die Abtastung sollte etwa 10mal so schnell erfolgen. Das heißt: alle 100ms - Drehzahl messen - Abweichung von Solldrehzahl zu Istdrehzahl berechnen - Mit PI-Regelalgorithmus neuen PWM-Wert berechnen und ausgeben Die 100ms müssen genau eingehalten werden, da der Regler sonst falsche Informationen bekommt und schwingt. Kannst ja erst mal mit einem P-Regler anfangen und den I-Anteil später hinzufügen.
Oliver H. schrieb: > Also ich stell mich vermutlich gerade sehr doof an, aber kann ich dann > für T_Abtast "einfach" 0,5s einsetzen und gut ist? Ja, natürlich. Nur ist es sinnvoll testweise die Abtastrate zu ändern (und dann eben entsprechendes einsetzen).
Also der Regler ist ja absolut schäbig. Hast du dir schon die Stellgröße angeschaut? Da schauen, dass du nicht ständig in der Stellgrößenbeschränkung rumrennst, sonst verkohlt dir dat ding min jong. Mit stellgrößenbescheränkung brauchste dann antiwindup sonst kannet den jeschlossenens kreis destabilisieren. Sonst bitte als Faustregel: 2pi/T >= 30*WB WB ist die Bandbreite des offenen Kreises. T die Abtastzeit. Dann ist die Totzeit, die durch die Abtastung in den Regelkreis kommt vernachlässigbar und ein Entwurf im Zeitkontinuierlichen mit anschließender Diskretisierung des Reglers z.b. mit tustin bedenklos möglich.
Wie hast du die Regelstrecke modelliert? Das sieht mir nach einem PT1 Glied aus. Aber eigentlich atypisch für Lüfter, da DC Motoren PT2 sind. Müsste eigentlich schwingen bei einem Sprung o.O
Thread beobachten
Seitenaufteilung abschaltenBitte 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.