Digitale Regelung - Exam

Aufgabe 1)

Digitale Regelungssysteme: Digitale Regelungssysteme nutzen digitale Komponenten wie Mikroprozessoren zur Steuerung und Regelung dynamischer Systeme. Diese Systeme bieten eine erhöhte Präzision und Anpassungsfähigkeit im Vergleich zu analogen Regelungssystemen und ermöglichen die Implementierung komplexer Algorithmen. Digitale Regelungssysteme arbeiten zeitdiskret, das bedeutet, dass die Zustände des Systems nur zu bestimmten Zeitpunkten aktualisiert werden. Zu den wichtigen Konzepten in diesem Bereich gehören das Abtasttheorem und die Z-Transformation. Sie bieten zahlreiche Vorteile wie Flexibilität, Skalierbarkeit und Wiederverwendbarkeit und finden Anwendung in diversen Bereichen wie der Automobilindustrie, der Robotik und der Prozesssteuerung. Die Grundstruktur eines digitalen Regelungssystems besteht typischerweise aus Sensoren, digitalen Controllern und Aktoren.

a)

Beschreibe detailliert den Unterschied zwischen analogen und digitalen Regelungssystemen. Gehe dabei insbesondere auf die Vorteile der digitalen Systeme ein.

Lösung:

Unterschied zwischen analogen und digitalen Regelungssystemen:

• Analoges Regelungssystem: Ein analoges Regelungssystem verwendet analoge Signale, um kontinuierlich eine physikalische Größe zu messen, zu regeln und zu steuern. Beispiele für analoge Signale sind elektrische Spannungen oder Ströme, die stufenlose Werte annehmen können. Die Steuerung erfolgt in Echtzeit und ist kontinuierlich. Die verwendeten Komponenten wie Operationsverstärker und andere elektronische Bauteile arbeiten im analogen Bereich.
• Digitales Regelungssystem: Ein digitales Regelungssystem verwendet digitale Komponenten wie Mikroprozessoren oder digitale Signalprozessoren (DSPs), um die Steuerung durchzuführen. Digitale Systeme arbeiten zeitdiskret, was bedeutet, dass die Zustände des Systems in regelmäßigen Zeitintervallen (Samples) aktualisiert werden. Signale werden mittels Analog-Digital-Wandler (ADC) abgetastet und in digitale Werte konvertiert.
• Vorteile digitaler Regelungssysteme:
  • Erhöhte Präzision: Durch die digitale Verarbeitung von Signalen kann eine höhere Genauigkeit bei der Berechnung und Regelung erreicht werden.
  • Flexibilität: Digitale Systeme können leicht neu programmiert werden, um unterschiedliche Regelungsalgorithmen zu implementieren und anzupassen.
  • Komplexe Algorithmen: Digitale Regelungssysteme ermöglichen die Implementierung und Anwendung komplexer Regelungsalgorithmen, die mit analogen Systemen nur schwer umsetzbar wären.
  • Wiederverwendbarkeit: Einmal entwickelte Softwarelösungen können in verschiedenen Projekten und Anwendungen wiederverwendet werden.
  • Skalierbarkeit: Digitale Lösungen lassen sich einfacher skalieren, um sie an verschiedene Anforderungen und Systemgrößen anzupassen.
  • Störsicherheit: Digitale Signale sind weniger anfällig für Rauschen und Störungen im Vergleich zu analogen Signalen.

c)

Ein digitales Regelungssystem nutzt die Z-Transformation zur Analyse und Berechnung von Systemantworten. Gib die Definition der Z-Transformation an und zeige, wie sie zur Analyse eines zeitdiskreten Systems verwendet wird. Verwende dazu ein konkretes Beispiel und die folgende Differenzengleichung:

y[n+1] = 0.5y[n] + x[n]

Lösung:

Definition der Z-Transformation: Die Z-Transformation ist ein mathematisches Werkzeug, das zur Analyse und Berechnung von zeitdiskreten Systemen verwendet wird. Sie wandelt eine zeitdiskrete Folge in einen Ausdruck im z-Bereich um, der leichter zu analysieren ist. Die Z-Transformation einer Folge \(x[n]\) wird definiert als:

• \[X(z) = \sum_{n=-\infty}^{\infty} x[n] \cdot z^{-n}\]

Dabei ist \(X(z)\) die Z-Transformierte von \(x[n]\) und \(z\) eine komplexe Variable. Anwendung der Z-Transformation zur Analyse eines zeitdiskreten Systems: Gegeben sei die Differenzengleichung eines Systems:

y[n+1] = 0.5y[n] + x[n]

Um die Z-Transformation anzuwenden, folgen wir diesen Schritten:

• Schritt 1: Verschiebung in der Zeit: Zuerst schreiben wir die Gleichung so, dass sie für alle \(n\) gilt.
\begin{align} y[n+1] = 0.5y[n] + x[n] \end{align}
• Schritt 2: Anwendung der Z-Transformation: Wir wenden die Z-Transformation auf beide Seiten der Differenzengleichung an. Dabei nutzen wir die Eigenschaft der Z-Transformation, dass eine Verschiebung um eine Einheit \(n\) gleich einer Multiplikation mit \(z^{-1}\) im z-Bereich ist:
\begin{align} \mathcal{Z}\{y[n+1]\} = \mathcal{Z}\{0.5y[n] + x[n]\} \end{align}
• Schritt 3: Verwendung der Zeitverschiebungseigenschaft: Die Z-Transformation einer um eine Einheit verschobenen Sequenz \(y[n+1]\) ist \(zY(z) - z\cdot y[0]\), wobei \(Y(z)\) die Z-Transformierte von \(y[n]\) ist und \(y[0]\) der Anfangswert:
\begin{align} zY(z) - z\cdot y[0] = 0.5Y(z) + X(z) \end{align}
• Schritt 4: Auflösen nach \(Y(z)\): Wir bringen alle Terme mit \(Y(z)\) auf eine Seite der Gleichung:
\begin{align} zY(z) - 0.5Y(z) = X(z) + z\cdot y[0] \end{align} Das können wir vereinfachen zu: \begin{align} (z - 0.5)Y(z) = X(z) + z\cdot y[0] \end{align}
• Schritt 5: Lösung für \(Y(z)\): Wir lösen nach \(Y(z)\) auf:
\begin{align} Y(z) = \frac{X(z) + z\cdot y[0]}{z - 0.5} \end{align}

Interpretation: Diese Gleichung zeigt, wie die Z-Transformierte der Systemantwort \(Y(z)\) in Abhängigkeit von der Eingabe \(X(z)\) und dem Anfangswert \(y[0]\) aussieht. Durch die Rücktransformation aus dem z-Bereich in den Zeitbereich können wir das Verhalten des Systems analysieren und die Ausgangswerte \(y[n]\) berechnen.

d)

Skizziere ein Blockdiagramm eines digitalen Regelungssystems und erläutere die Funktionen der einzelnen Komponenten (Sensoren, Digitale Controller, Aktoren). Beschreibe, welche Rolle jeder dieser Komponenten in dem System spielt.

Lösung:

Blockdiagramm eines digitalen Regelungssystems

• Systembeschreibung: Das digitale Regelungssystem besteht aus mehreren wesentlichen Komponenten: Sensoren, Digitaler Controller und Aktoren. Diese Komponenten arbeiten zusammen, um das System in Echtzeit zu überwachen und zu steuern.
• Blockdiagramm: Das Diagramm zeigt den Fluss von Signalen innerhalb des Systems:
  • Sensoren: Die Sensoren (S) messen physikalische Zustände und Größen des zu regelnden Prozesses oder Systems. Beispiele sind Temperatur-, Druck- oder Positionssensoren. Ihre Hauptaufgabe besteht darin, kontinuierliche analoge Signale in gepulste, diskrete (digitale) Signale umzuwandeln, die dann an den Digitalcontroller weitergegeben werden. Die Ausgangssignale der Sensoren repräsentieren den aktuellen Zustand des Systems.
  • Analoge-Digital-Wandler (ADC): Die analogen Signale der Sensoren müssen in digitale Signale umgewandelt werden. Dies geschieht durch einen ADC, der die analogen Messwerte in diskrete Werte konvertiert.
  • Digitaler Controller: Der digitale Controller (DC) empfängt die digitalisierten Signale von den Sensoren und vergleicht sie mit den Sollwerten. Basierend auf den Unterschieden (Fehlern) und unter Verwendung geeigneter Regelungsalgorithmen generiert er Steuerbefehle, die an die Aktoren gesendet werden. Diese Algorithmen können einfach (z. B. PID-Regler) oder komplex (z. B. Modellprädiktive Regelung) sein. Der gesamte Prozess erfolgt diskret, also zu festgelegten Zeitpunkten.
  • Digital-zu-Analog Wandler (DAC): Der DAC konvertiert die digitalen Steuerbefehle des Controllers wieder in analoge Signale, die von den Aktoren verstanden werden können.
  • Aktoren: Die Aktoren (A) setzen die Steuerbefehle des digitalen Controllers in physikalische Aktionen um. Beispiele sind Motoren, Ventile oder Heizelemente. Ihre Aufgabe ist es, den Zustand des Systems zu ändern oder zu beeinflussen, um den gewünschten Effekt zu erzielen. Diese Maßnahmen werden normalerweise als analoge Signale an das System zurückgegeben.
• Rolle der Komponenten:
  • Sensoren: Erfassen und überwachen kontinuierlich den Zustand des Systems und liefern die notwendigen Daten zur Regelung.
  • Digitale Controller: Bildet das Gehirn des Regelungssystems. Es verarbeitet die Messdaten der Sensoren, berechnet die notwendigen Steuerbefehle und überwacht den gesamten Regelungsprozess.
  • Aktoren: Setzen die Steuerbefehle des Controllers in physikalische Aktionen um und beeinflussen somit das dynamische Verhalten des Systems.

Aufgabe 2)

Ein diskretes lineares zeitinvariantes System ist wie folgt im Zustandsraum dargestellt:

• Systembeschreibung durch Zustandsvariablen: \( \textbf{x}(k+1) = \textbf{A}\textbf{x}(k) + \textbf{B}\textbf{u}(k) \)
• Ausgangsgleichung: \( \textbf{y}(k) = \textbf{C}\textbf{x}(k) + \textbf{D}\textbf{u}(k) \)
• Die Matrizen sind gegeben als:
  • \( \textbf{A} = \begin{pmatrix} 1 & 2 \ 0 & 1 \end{pmatrix} \)
  • \( \textbf{B} = \begin{pmatrix} 0 \ 1 \end{pmatrix} \)
  • \( \textbf{C} = \begin{pmatrix} 1 & 0 \end{pmatrix} \)
  • \( \textbf{D} = 0 \)

b)

Teilaufgabe 2: Überprüfe, ob das System steuerbar ist. Dazu berechne die Steuerbarkeitsmatrix \( \mathcal{C} = \begin{pmatrix} \textbf{B} & \textbf{A}\textbf{B} \end{pmatrix} \) und überprüfe, ob \( \textbf{C} \) den vollen Rang besitzt.

Lösung:

Um die Steuerbarkeit des Systems zu überprüfen, berechnen wir die Steuerbarkeitsmatrix \( \mathcal{C} \). Die Steuerbarkeitsmatrix wird definiert als:

• \( \mathcal{C} = \begin{pmatrix} \textbf{B} & \textbf{A}\textbf{B} \end{pmatrix} \)

Gegeben sind:

• \( \textbf{A} = \begin{pmatrix} 1 & 2 \ 0 & 1 \end{pmatrix} \)
• \( \textbf{B} = \begin{pmatrix} 0 \ 1 \end{pmatrix} \)

Zuerst berechnen wir \( \textbf{A}\textbf{B} \):

• \( \textbf{A}\textbf{B} = \begin{pmatrix} 1 & 2 \ 0 & 1 \end{pmatrix} \begin{pmatrix} 0 \ 1 \end{pmatrix} = \begin{pmatrix} 2 \ 1 \end{pmatrix} \)

Jetzt können wir die Steuerbarkeitsmatrix \( \mathcal{C} \) aufstellen:

• \( \mathcal{C} = \begin{pmatrix} \textbf{B} & \textbf{A}\textbf{B} \end{pmatrix} = \begin{pmatrix} 0 & 2 \ 1 & 1 \end{pmatrix} \)

Um die Steuerbarkeit zu überprüfen, müssen wir den Rang der Matrix \( \mathcal{C} \) berechnen. Eine Matrix ist vollrangig, wenn ihr Rang gleich der Anzahl ihrer Zeilen oder Spalten ist. Hier hat \( \mathcal{C} \) 2 Zeilen und 2 Spalten:

• \( \mathcal{C} = \begin{pmatrix} 0 & 2 \ 1 & 1 \end{pmatrix} \)

Wir überprüfen den Rang:

Die Determinante der Matrix \( \mathcal{C} \) ist:

• \( \text{det}(\mathcal{C}) = 0 \times 1 - 1 \times 2 = -2 \)

Da die Determinante ungleich Null ist, ist der Rang von \( \mathcal{C} \) gleich 2.

Da der Rang von \( \mathcal{C} \) 2 ist, was der Anzahl der Zustandsvariablen entspricht, ist das System steuerbar. Zusammenfassend:

• Die Steuerbarkeitsmatrix \( \mathcal{C} = \begin{pmatrix} 0 & 2 \ 1 & 1 \end{pmatrix} \) hat den vollen Rang 2.
• Das System ist daher steuerbar.

Aufgabe 3)

Gegeben: Ein lineares, zeitinvariantes System mit der Übertragungsfunktion G(s). Nutze die Frequenzganganalyse, um die Stabilität des Systems zu bestimmen. Nutze Nyquist- und Bode-Diagramme für die Analyse.

b)

(b) >Mit dem Bode-Diagramm bestimmst Du die Phasen- und Amplitudenreserve:

• Zeichne den Bode-Plot von \[G(j\textbackslash omega) = \frac{30(s+1)}{s(s+10)}\]
• Gib die Phasenreserv und Amplitudenreserve an. Nutze diese Reserven, um die Stabilität des Systems zu beurteilen.

Lösung:

Gegeben: Ein lineares, zeitinvariantes System mit der Übertragungsfunktion G(s). Nutze die Frequenzganganalyse, um die Stabilität des Systems zu bestimmen. Nutze Nyquist- und Bode-Diagramme für die Analyse. (b) Mit dem Bode-Diagramm bestimmst Du die Phasen- und Amplitudenreserve:

• Zeichne den Bode-Plot von \[G(j\omega) = \frac{30(j\omega + 1)}{j\omega(j\omega + 10)}\]
• Gib die Phasenreserve und Amplitudenreserve an. Nutze diese Reserven, um die Stabilität des Systems zu beurteilen.

Um den Bode-Plot der Übertragungsfunktion \( G(j\omega) = \frac{30(j\omega + 1)}{j\omega(j\omega + 10)} \) zu zeichnen, folge diesen Schritten:Schritt 1: Frequenzganganalyse und G(jω) definieren

• Setze s gleich jω (mit ω als Frequenz): \[G(j\omega) = \frac{30(j\omega + 1)}{j\omega(j\omega + 10)}\]
• Vereinfachung des Ausdrucks: \[G(j\omega) = \frac{30(j\omega + 1)}{j^2\omega^2 + 10j\omega}\]
• Komplexen Nenner weiter vereinfachen: \[G(j\omega) = \frac{30(j\omega + 1)}{-\omega^2 + 10j\omega}\]

Schritt 2: Bode-Plot zeichnen

• Bestimme den Betrag von \( G(j\omega) \) in Dezibel (dB): \[ 20 \log_{10} \left| G(j\omega) \right| \]
• Bestimme die Phase von \( G(j\omega) \) in Grad: \[ \arg \left( G(j\omega) \right) \]
• Zeichne diese beiden Kurven in Abhängigkeit von \( \omega \) auf einer logarithmischen Frequenzskala. Wichtige Frequenzpunkte sind dabei die Eckfrequenzen bei \( \omega = 1 \) und \( \omega = 10 \).

Schritt 3: Phasen- und Amplitudenreserve bestimmen

• Die Amplitudenreserve ist der Betrag bei der Frequenz, bei der die Phasenkurve -180 Grad erreicht.Amplitudenreserve = 0 dB - (abgelesener Amplitudenwert bei -180 Grad)
• Die Phasenreserve ist die Phasenverschiebung bei der Frequenz, bei der die Betragskurve 0 dB erreicht.Phasenreserve = 180 Grad - (abgelesene Phasenverschiebung bei 0 dB)

Stabilitätsbeurteilung:

• Ein System ist stabil, wenn beide Reserven positiv sind. Positiv bedeutet, dass die Amplitudenreserve > 0 dB ist und die Phasenreserve mindestens 0 Grad beträgt.
• In der Regel wird eine Phasenreserve von mindestens 30 Grad und eine Amplitudenreserve von mindestens 6 dB als stabilitätsfördernd angesehen.

Aufgabe 4)

Entwicklung und Realisierung digitaler PID-Regler zur Prozesssteuerung:

• PID-Regler berücksichtigt Anteil der Abweichung (P), Summe der Abweichungen (I) und Rate der Abweichungsänderung (D).
• Zeitdiskrete Version nutzen: \[u[k] = K_p \Big(e[k] + \frac{T_s}{T_i} \sum_{i=0}^{k} e[i] + \frac{T_d}{T_s} (e[k] - e[k-1]) \Big)\]
• Diskretisierungsverfahren (z.B. Tustin, vorwärts/rückwärts Differenzenmethode).
• Wahl der Abtastzeit (T_s) entscheidend.
• Antiwindup-Strategien zur Begrenzung der Integralsättigung implementieren.

a)

(1) Implementierung des PID-Reglers: Schreibe ein Python-Programm, das einen zeitdiskreten PID-Regler gemäß der gegebenen Gleichung implementiert. Nutze folgende Parameter:

• Proportionalitätskonstante: K_p = 2.0
• Integrationszeitkonstante: T_i = 1.0
• Differentialzeitkonstante: T_d = 0.1
• Abtastzeit: T_s = 0.01

Das Programm soll die Regelgröße u[k] basierend auf den Fehlerwerten e[k] und e[k-1] für k = 0 bis 100 berechnen und in einer Liste speichern.

import numpy as np# ParameterK_p = 2.0T_i = 1.0T_d = 0.1T_s = 0.01# Fehlerwerte e[k] und e[k-1]errors = np.random.randn(101)  # Beispielhafte Fehlerwerte# Liste zur Speicherung der Regelgröße u[k]u = [0]  # Initialisierung mit u[0]for k in range(1, 101):    integral_sum = sum(errors[:k+1]) * T_s  # Integrierte Fehler    derivative = (errors[k] - errors[k-1]) / T_s  # Differenzierte Fehler    u_k = K_p * (errors[k] + (T_s/T_i) * integral_sum + (T_d/T_s) * derivative)    u.append(u_k)print(u)

Lösung:

Entwicklung und Realisierung digitaler PID-Regler zur Prozesssteuerung:

• PID-Regler berücksichtigt Anteil der Abweichung (P), Summe der Abweichungen (I) und Rate der Abweichungsänderung (D).
• Zeitdiskrete Version nutzen: \(u[k] = K_p \Big(e[k] + \frac{T_s}{T_i} \sum_{i=0}^{k} e[i] + \frac{T_d}{T_s} (e[k] - e[k-1]) \Big)\)
• Diskretisierungsverfahren (z.B. Tustin, vorwärts/rückwärts Differenzenmethode).
• Wahl der Abtastzeit (T_s) entscheidend.
• Antiwindup-Strategien zur Begrenzung der Integralsättigung implementieren.

(1) Implementierung des PID-Reglers:

Schreibe ein Python-Programm, das einen zeitdiskreten PID-Regler gemäß der gegebenen Gleichung implementiert. Nutze folgende Parameter:

• Proportionalitätskonstante: K_p = 2.0
• Integrationszeitkonstante: T_i = 1.0
• Differentialzeitkonstante: T_d = 0.1
• Abtastzeit: T_s = 0.01

Das Programm soll die Regelgröße u[k] basierend auf den Fehlerwerten e[k] und e[k-1] für k = 0 bis 100 berechnen und in einer Liste speichern.

import numpy as np# ParameterK_p = 2.0T_i = 1.0T_d = 0.1T_s = 0.01# Fehlerwerte e[k] und e[k-1]errors = np.random.randn(101)  # Beispielhafte Fehlerwerte# Liste zur Speicherung der Regelgröße u[k]u = [0]  # Initialisierung mit u[0]for k in range(1, 101):    integral_sum = sum(errors[:k+1]) * T_s  # Integrierte Fehler    derivative = (errors[k] - errors[k-1]) / T_s  # Differenzierte Fehler    u_k = K_p * (errors[k] + (T_s/T_i) * integral_sum + (T_d/T_s) * derivative)    u.append(u_k)print(u)

b)

(2) Analyse und Optimierung der Regelung: Wähle für den implementierten PID-Regler eine geeignete Antiwindup-Strategie, um die Integralsättigung zu begrenzen und beschreibe deren Funktionsweise. Implementiere diese Strategie in das zuvor geschriebene Python-Programm und führe eine Simulation durch, die die Wirksamkeit der Antiwindup-Maßnahme verdeutlicht. Nutze dabei dieselben Parameter wie in Teil (1).

Ein einfacher Ansatz könnte das Clamping sein, bei dem die Integralkomponente eingefroren wird, wenn der Ausgang u[k] die Sättigungsgrenze überschreitet. Das modifizierte Programm könnte wie folgt aussehen:

import numpy as np# ParameterK_p = 2.0T_i = 1.0T_d = 0.1T_s = 0.01u_max = 10  # Sättigungsgrenzeu_min = -10  # Negative Sättigungsgrenze# Fehlerwerte e[k] und e[k-1]errors = np.random.randn(101)  # Beispielhafte Fehlerwerte# Liste zur Speicherung der Regelgröße u[k]u = [0]  # Initialisierung mit u[0]integral_sum = 0  # Summe der integrierten Fehlerwertefor k in range(1, 101):    integral_sum += errors[k] * T_s  # Integrierte Fehler    derivative = (errors[k] - errors[k-1]) / T_s  # Differenzierte Fehler    u_k = K_p * (errors[k] + (T_s/T_i) * integral_sum + (T_d/T_s) * derivative)    # Antiwindup: Begrenzung der Regelgröße u[k]    if u_k > u_max:        u_k = u_max        integral_sum -= errors[k] * T_s  # Sperre die Integralkomponente    elif u_k < u_min:        u_k = u_min        integral_sum -= errors[k] * T_s  # Sperre die Integralkomponente    u.append(u_k)print(u)

Lösung:

Entwicklung und Realisierung digitaler PID-Regler zur Prozesssteuerung:

• PID-Regler berücksichtigt Anteil der Abweichung (P), Summe der Abweichungen (I) und Rate der Abweichungsänderung (D).
• Zeitdiskrete Version nutzen: \(u[k] = K_p \Big(e[k] + \frac{T_s}{T_i} \sum_{i=0}^{k} e[i] + \frac{T_d}{T_s} (e[k] - e[k-1]) \Big)\)
• Diskretisierungsverfahren (z.B. Tustin, vorwärts/rückwärts Differenzenmethode).
• Wahl der Abtastzeit (T_s) entscheidend.
• Antiwindup-Strategien zur Begrenzung der Integralsättigung implementieren.

(2) Analyse und Optimierung der Regelung:

Wähle für den implementierten PID-Regler eine geeignete Antiwindup-Strategie, um die Integralsättigung zu begrenzen und beschreibe deren Funktionsweise. Implementiere diese Strategie in das zuvor geschriebene Python-Programm und führe eine Simulation durch, die die Wirksamkeit der Antiwindup-Maßnahme verdeutlicht. Nutze dabei dieselben Parameter wie in Teil (1).

Ein einfacher Ansatz könnte das Clamping sein, bei dem die Integralkomponente eingefroren wird, wenn der Ausgang \(u[k]\) die Sättigungsgrenze überschreitet. Das modifizierte Programm könnte wie folgt aussehen:

import numpy as np# ParameterK_p = 2.0T_i = 1.0T_d = 0.1T_s = 0.01u_max = 10  # Sättigungsgrenzeu_min = -10  # Negative Sättigungsgrenze# Fehlerwerte e[k] und e[k-1]errors = np.random.randn(101)  # Beispielhafte Fehlerwerte# Liste zur Speicherung der Regelgröße u[k]u = [0]  # Initialisierung mit u[0]integral_sum = 0  # Summe der integrierten Fehlerwertefor k in range(1, 101):    integral_sum += errors[k] * T_s  # Integrierte Fehler    derivative = (errors[k] - errors[k-1]) / T_s  # Differenzierte Fehler    u_k = K_p * (errors[k] + (T_s/T_i) * integral_sum + (T_d/T_s) * derivative)    # Antiwindup: Begrenzung der Regelgröße u[k]    if u_k > u_max:        u_k = u_max        integral_sum -= errors[k] * T_s  # Sperre die Integralkomponente    elif u_k < u_min:        u_k = u_min        integral_sum -= errors[k] * T_s  # Sperre die Integralkomponente    u.append(u_k)print(u)