# Grundglieder
Die in @tbl-gliederung aufgeführten Übertragungsglieder bilden die Basis für die Modellierung realer Regelstrecken in der Simulation. Wir nennen diese deshalb *Grundglieder* und wollen sie im Folgenden etwas näher betrachten.
::: {.callout-important title="Ziele"}
- Du kennst die typischen Übertragungsglieder (*Grundglieder*) und kannst ihr Verhalten beschreiben.
- Du kannst mit den *Grundgliedern* in <span class="cap">Boris</span> eine Regelstrecke aufbauen und die Sprungantwort simulieren.
- Du kannst ein System in Bezug auf die Regelbarkeit anhand der Verzugs- $T_e$ bzw. Ausgleichszeit $T_b$ beurteilen.
:::
Wir haben gelernt, dass eine Regelstrecke in eine der beiden Klassen fällt:
- **Strecken mit Ausgleich** (P-Strecken bzw. allgemein P-Glieder genannt)
- **Strecken ohne Ausgleich** (I-Strecken bzw. allgemein I-Glieder genannt)
## Glieder mit Ausgleich (P-Glieder)
Bei allen Übertragungsgliedern mit Ausgleich (P-Glieder) erreicht die Ausgangsgrösse $x_a$ bei einer konstanten Eingangsgrösse $x_e$ einen stationären Endwert. Es wird also ein *Beharrungszustand* erreicht, wobei der stationäre Endwert *proportional* zur Eingangsgrösse ist (daher kommt der Name *P-Glieder*).
$$
x_a = K_P \cdot x_e \qquad \textsf{(Beharrungszustand)}
$$ {#eq-kp}
Die **Kennlinie** (Ausgangsgrösse $x_a$ in Abhängigkeit der Eingangsgrösse $x_e$ im Beharrungszustand) ist eine Gerade, die durch den Ursprung geht und deren Steigung dem Proportionalbeiwert $K_P$ entspricht ($K_P = \frac{\Delta x_a}{\Delta x_e}$). Sämtliche P-Glieder, die wir im Folgenden betrachten, weisen daher qualitativ dieselbe Kennlinie auf.
{width=80% #fig-kennlinie-allg}
Das *statische Verhalten* bzw. den Proportionalbeiwert $K_P$ werden wir an dieser Stelle nicht weiter behandeln. Im Folgenden gehen wir sämtliche Grundglieder durch und betrachten primär das *dynamische Verhalten* anhand der **Sprungantwort**.
### P-Glied {.unnumbered}
Das (reine) P-Glied weist keine Verzögerung auf, d. h. der Ausgang folgt dem Eingang sofort. Ein P-Glied ist also nichts anderes als eine Skalierung (Multiplikation mit $K_P$) und ist folglich mit dem Proportionalbeiwert $K_P$ vollständig beschrieben.
$$
x_a(t) = K_P \cdot x_e(t)
$$
::: {#fig-P layout="[25,75]"}


P-Glied
:::
Typische Beispiele sind:
- Übersetzung (z. B. ein Getriebe, wo eine Drehzahl bzw. ein Drehmoment umgewandelt wird)
- Transformator
- Spannungsteiler
- allg. jede Skalierung (z. B. ein Sensor, der eine physikalische Grösse in eine elektrische Grösse umwandelt, ohne dass dabei eine nennenswerte Verzögerung auftritt)
### P-T~1~-Glied {.unnumbered}
Reale Systeme weisen häufig Energiespeicher auf, die geladen/entladen werden müssen. Dies führt zu Verzögerungen, d. h. der Ausgang folgt dem Eingang nicht sofort, sondern zeitlich verzögert. Das einfachste Übertragungsglied mit einer Verzögerung ist das P-T~1~-Glied, das neben dem Proportionalbeiwert $K_P$ durch die Zeitkonstante $T_1$ beschrieben wird.
$$
T_1 \cdot \dot{x}_a(t) + x_a(t) = K_P \cdot x_e(t)
$$
Die Ordnung der obigen Differentialgleichung ist 1 (=höchste Ableitung), d. h. wir nennen das P-T~1~-Glied auch **Verzögerungsglied 1. Ordnung**.
Die Zeitkonstante $T_1$ kann direkt aus der Sprungantwort herausgelesen werden.
::: {#fig-PT1 layout="[25,75]"}


P-T~1~-Glied
:::
::: {.callout-note title="e-Funktion"}
Wir werden uns nicht mit dem Lösen von Differentialgleichungen befassen, doch wir können mitnehmen, dass in der Lösung solcher Differentialgleichungen typischerweise Exponentialfunktionen auftreten. Darum zeigt der Ausgangswert in der obigen Sprungantwort typisches exponentielles Sättigungsverhalten.
Die genaue Lösung für die Sprungantwort eines P-T~1~-Gliedes für einen Einheitssprung am Eingang lautet:
$$
x_a(t) = K_P \cdot \left(1 - e^{-\frac{t}{T_1}}\right)
$$
:::
Ein klassisches Beispiel für ein P-T~1~-Glied ist ein RC-Glied, bei dem ein Kondensator über einen Widerstand geladen/entladen wird. Ein weiteres Beispiel ist ein Druckbehälter, der über eine Drossel gefüllt wird. Allg. können sehr viele Systeme näherungsweise als P-T~1~-Glied betrachtet werden, da häufig ein Energiespeicher das Verhalten dominiert (auch wenn effektiv mehrere Energiespeicher vorhanden sind).
::: {#fig-PT1Bsp layout="[52,45]"}
{width=80% #fig-rc1}
{#fig-rc2}
RC-Glied [Quelle](https://de.wikipedia.org/wiki/RC-Glied)
:::
### P-T~2~-Glied {.unnumbered}
Enthält das System zwei (*gleichartige*) Energiespeicher (z. B. zwei RC-Glieder in Reihe oder zwei Druckbehälter in Reihe etc.), so sprechen wir von einem P-T~2~-Glied. Es sind dann zwei Zeitkonstanten $T_1$ und $T_2$ zur Beschreibung notwendig.
$$
T_1 \cdot T_2 \cdot \ddot{x}_a(t) + (T_1+T_2) \cdot \dot{x}_a(t) + x_a(t) = K_P \cdot x_e(t)
$$
In der obigen Differentialgleichung ist eine zweite Ableitung vorhanden, d. h. wir nennen das P-T~2~-Glied auch **Verzögerungsglied 2. Ordnung**.
::: {#fig-PT2 layout="[25,75]"}


P-T~2~-Glied
:::
Die Zeitkonstanten $T_1$ bzw. $T_2$ des P-T~2~-Gliedes können nicht direkt aus der Sprungantwort herausgelesen werden. Anhand der **Wendetangente** können die sogenannten Ersatzzeitkonstanten $T_e$ (Verzugszeit) bzw. $T_b$ (Ausgleichszeit) bestimmt werden. Wir werden in @sec-id Verfahren kennenlernen, um damit die effektiven Zeitkonstanten $T_1$ bzw. $T_2$ zu bestimmen.
::: {.callout-note title="Wendetangente" #nte-wt}
Die Wendetangente ist die Tangente an die Sprungantwort im Wendepunkt, d. h. dort, wo die Krümmung von positiv (Gegenuhrzeigersinn) nach negativ (Uhrzeigersinn) wechselt. Dies ist gleichzeitig auch die steilste Stelle der Sprungantwort. Die Wendetangente schneidet die Zeitachse bei der Verzugszeit $T_e$ und von dort bis zum Zeitpunkt, bei dem der Wert des stationären Endwertes erreicht wird, können wir die Ausgleichszeit $T_b$ ablesen.
{fig-align="center"}
:::
@fig-PT2Bsp zeigt zwei typische Beispiele für P-T~2~-Glieder.
::: {#fig-PT2Bsp layout="[56,44]"}
{#fig-rcs}
{#fig-tanks}
P-T~2~-Beispiele [@crashkurs]
:::
::: {.callout-note title="Reihenschaltung von Übertragungsgliedern"}
Ein P-T~2~-Glied kann als Reihenschaltung von zwei P-T~1~-Gliedern aufgefasst werden. Dies gilt ganz allgemein, d. h. ein P-T~3~-Glied kann als Reihenschaltung von drei P-T~1~-Gliedern aufgefasst werden (oder alternativ als Reihenschaltung von einem P-T~2~-Glied und einem P-T~1~-Glied etc.).
:::
### P-T~2S~-Glied {.unnumbered}
Enthält das Übertragungsglied zwei Energiespeicher, die *nicht gleichartig* sind, so kann es zu oszillierenden Energietransfers zwischen diesen Energiespeichern kommen und damit zu *Schwingungen*. Wir nennen das Übertragungsglied dann P-T~2S~ (S für *schwingfähig*) und beschreiben es mit der Kennkreisfrequenz $\omega_0$ und dem Dämpfungsgrad $D$.
$$
\frac{1}{\omega_0^2} \cdot \ddot{x}_a(t) + 2 \cdot \frac{D}{\omega_0} \cdot \dot{x}_a(t) + x_a(t) = K_P \cdot x_e(t)
$$
::: {#fig-PT2S layout="[25,75]"}


P-T~2S~-Glied
:::
Die Kennkreisfrequenz $\omega_0$ und der Dämpfungsgrad $D$ können anhand der folgenden Beziehungen aus der Sprungantwort bestimmt werden. Die Kennkreisfrequenz $\omega_0$ ist die charakteristische Frequenz des Systems (mit dieser Frequenz schwingt das System, wenn es ungedämpft ist). Der Dämpfungsgrad $D$ besagt, wie rasch die Schwingung abklingt ($0 < D < 1$). Bei $D = 1$ ist das System *kritisch gedämpft* und schwingt nicht mehr, d. h. es wird zum (nicht-schwingfähigen) P-T~2~-Glied.
$$
D = \frac{\ln{\frac{\Delta_1}{\Delta_2}}}{\sqrt{4 \pi^2 + \ln{\frac{\Delta_1}{\Delta_2}}}}
$$
$$
\omega_0 = \frac{2 \pi}{\tau \sqrt{1 - D^2}}
$$
P-T~2S~-Glieder sind sehr verbreitet in mechanischen Systemen mit Massen/Federn/Dämpfern bzw. elastischen Elementen (z. B. bei Kupplungen) oder auch in elektrischen Schwingkreisen (LC-Glieder usw.).
::: {#fig-PT2SBsp}
{width=50% #fig-mass-spring-damper}
Masse-Feder-System [Quelle](https://tex.stackexchange.com/questions/640906/animate-mass-spring-damper-tikz)
:::
### P-T~n~-Glied {.unnumbered}
Natürlich können auch mehr als zwei Energiespeicher auftreten, was zu P-T~3~-, P-T~4~-, ..., P-T~n~-Gliedern führt. Die Sprungantworten solcher Glieder sehen qualitativ alle ähnlich aus wie das P-T~2~-Glied, da sie lediglich stärker verzögert sind.
Nachfolgend ist stellvertretend ein P-T~3~-Glied aufgeführt (analog für P-T~4~ usw.).
$$
\begin{aligned}
T_1 \cdot T_2 \cdot T_3 \cdot \dddot{x}_a(t)
&+ (T_1 \cdot T_2 + T_1 \cdot T_3 + T_2 \cdot T_3) \cdot \ddot{x}_a(t) \\
&+ (T_1 + T_2 + T_3) \cdot \dot{x}_a(t)
+ x_a(t) \\
&= K_P \cdot x_e(t)
\end{aligned}
$$
::: {#fig-PTn layout="[25,75]"}


P-T~n~-Glied
:::
Wie beim P-T~2~-Glied können die Zeitkonstanten $T_1, \dots, T_n$ bei P-T~n~-Gliedern nicht direkt aus der Sprungantwort bestimmt werden, d. h. es können wiederum lediglich Verzugszeit $T_e$ bzw. Ausgleichszeit $T_b$ anhand der Wendetangente (vgl. @nte-wt) bestimmt werden.
::: {.callout-note title="P-T~n~-Glied in BORIS"}
Beim P-T~n~-Glied in <span class="cap">Boris</span> werden alle $n$ Zeitkonstanten $T_1, \dots, T_n$ als identisch angenommen, d. h. es wird ein P-T~n~-Glied mit identischen Zeitkonstanten modelliert ($T_1 = T_2 = \dots = T_n$).
Will man ein P-T~n~-Glied mit unterschiedlichen Zeitkonstanten modellieren, so muss eine Reihenschaltung von mehreren P-T~1~ oder P-T~2~-Gliedern erstellt werden.
:::
### P-T~t~-Glied {.unnumbered}
Es gibt auch Verzögerungen, die nicht von Energiespeichern verursacht werden, sondern aufgrund von Transportvorgängen/Laufzeiten (typisch für Stofftransporte in Fördereinrichtungen/Rohrleitungen etc.). Eine solche Verzögerung wird **Totzeit** $T_t$ genannt und verhält sich fundamental anders als die oben betrachteten Verzögerungen. Eine Änderung am Eingang zeigt sich am Ausgang erst nach Ablauf der Totzeit, doch dann schlagartig. Das P-T~t~-Glied wird folglich als **Totzeitglied** bezeichnet.
$$
x_a(t) = K_P \cdot x_e(t - T_t)
$$
::: {#fig-PTt layout="[25,75]"}


P-T~t~-Glied (Totzeit)
:::
Ein typisches Beispiel für ein P-T~t~-Glied ist ein Förderband-Prozess (vgl. @fig-PTtBsp), wo zwischen Eingriff des Stellgliedes und der Erfassung durch das Messglied eine gewisse Zeit verstreicht.
::: {#fig-PTtBsp}
{width=60% #fig-foerderband}
Förderband [Quelle](https://instrumentationtools.com/dead-time/)
:::
Den Effekt der Totzeit kann man in der folgenden interaktiven Demo sehr schön sehen. Die Aufgabe besteht darin, durch Mausbewegungen die rote Linie möglichst genau auf der schwarzen Linie zu halten. Spiele kurz damit herum, du wirst rasch feststellen, dass das relativ gut geht. Dies ändert sich aber drastisch, wenn eine Totzeit auftritt, d. h. zwischen Änderung der Mausposition (="Eingang") und Höhenänderung der Linie (="Ausgang") eine Verzögerung auftritt. Mit dem Slider über dem Diagramm kannst du die Totzeit konfigurieren (von 0 bis 2 s).
::: {.deadtime-demo}
```{ojs}
//| echo: false
deadTimeSlider = html`<input type="range" min="0" max="2000" step="50" value="0" style="width:350px;height:6px;cursor:pointer">`
deadTime = Generators.input(deadTimeSlider)
html`
<div style="text-align:center;margin-bottom:0.5em">
<div style="font-size:18px;font-weight:500;margin-bottom:0.5em">
Totzeit: ${(deadTime / 1000).toFixed(1)} s
</div>
<div style="display:flex;align-items:center;gap:0.75em;justify-content:center;">
<span style="font-size:16px">0 s</span>
${deadTimeSlider}
<span style="font-size:16px">2 s</span>
</div>
<div style="font-size:15px;color:#888;margin-top:0.5em">
Versuche die rote Linie durch vertikale Mausbewegungen möglichst auf der schwarzen Linie zu halten. Erhöhe die Totzeit (mit Pfeiltasten möglich) und beobachte wie die Totzeit die Aufgabe erschwert.
</div>
</div>`
```
```{ojs}
//| echo: false
sim = Generators.observe((change) => {
const mouseState = {y: 50, buffer: []};
const onMove = (e) => {
const plotEl = document.querySelector('.deadtime-plot');
if (!plotEl) return;
const rect = plotEl.getBoundingClientRect();
const relY = e.clientY - rect.top;
const plotAreaTop = 30;
const plotAreaBottom = rect.height - 40;
const plotAreaHeight = plotAreaBottom - plotAreaTop;
const dataY = 100 * (1 - (relY - plotAreaTop) / plotAreaHeight);
mouseState.y = Math.max(0, Math.min(100, dataY));
mouseState.buffer.push({t: performance.now(), y: mouseState.y});
};
document.addEventListener('mousemove', onMove);
const onKeyDown = (e) => {
if (e.target.tagName === 'INPUT' || e.target.tagName === 'TEXTAREA' || e.target.isContentEditable) return;
if (e.key === 'ArrowLeft') {
const newVal = Math.max(0, parseInt(deadTimeSlider.value) - 50);
deadTimeSlider.value = newVal;
deadTimeSlider.dispatchEvent(new Event('input', {bubbles: true}));
e.preventDefault();
} else if (e.key === 'ArrowRight') {
const newVal = Math.min(2000, parseInt(deadTimeSlider.value) + 50);
deadTimeSlider.value = newVal;
deadTimeSlider.dispatchEvent(new Event('input', {bubbles: true}));
e.preventDefault();
}
};
document.addEventListener('keydown', onKeyDown);
let t = 0;
let currentRef = 50;
let intermediate = 50;
let targetRef = 50;
let nextChange = 7;
const alpha = 0.1;
const refData = [];
const dt = 0.05;
const id = setInterval(() => {
t += dt;
if (t >= nextChange) {
targetRef = 5 + Math.random() * 90;
nextChange = t + 7;
}
intermediate = (1 - alpha) * intermediate + alpha * targetRef;
currentRef = (1 - alpha) * currentRef + alpha * intermediate;
refData.push({t, y: currentRef});
while (refData.length > 0 && t - refData[0].t > 15) {
refData.shift();
}
const delay = parseInt(deadTimeSlider.value);
const xMin = Math.max(0, t - 15);
const xMax = Math.max(15, t);
const center = (xMin + xMax) / 2;
const delayedData = [];
const now = performance.now();
const buf = mouseState.buffer;
const n = Math.round((center - xMin) / dt);
for (let i = 0; i <= n; i++) {
const ts = xMin + i * dt;
const lookAhead = Math.max(0, (center - ts) * 1000);
const targetTime = now - delay - lookAhead;
let y = mouseState.y;
if (buf.length > 0) {
let idx = 0;
while (idx < buf.length - 1 && buf[idx + 1].t <= targetTime) idx++;
y = buf[idx].y;
}
delayedData.push({t: ts, y});
}
change({ref: refData.slice(), delayed: delayedData, now: t});
}, dt * 1000);
return () => {
clearInterval(id);
document.removeEventListener('mousemove', onMove);
document.removeEventListener('keydown', onKeyDown);
};
})
```
```{ojs}
//| echo: false
x_max = sim?.now || 0
html`<div class="deadtime-plot" style="display:flex;flex-direction:column;align-items:center;width:100%;cursor:none;">
${
Plot.plot({
height: 480,
marginLeft: 55,
marginTop: 30,
marginBottom: 40,
marginRight: 55,
style: {background: "transparent", color: "#333", fontSize: "14px"},
x: {label: "Zeit [s]", labelAnchor: "center", grid: true, domain: [Math.max(0, x_max - 15), Math.max(15, x_max)]},
y: {domain: [0, 100], axis: null},
marks: [
Plot.lineY(sim?.ref || [], {x: "t", y: "y", stroke: "#333", strokeWidth: 2.5}),
Plot.lineY(sim?.delayed || [], {x: "t", y: "y", stroke: "#e74c3c", strokeWidth: 2.5}),
]
})
}
</div>`
```
:::
## Glieder ohne Ausgleich (I-Glieder)
Wie wir bereits wissen, weisen Übertragungsglieder ohne Ausgleich (I-Glieder) **keinen Beharrungszustand** auf, d. h. die Ausgangsgrösse $x_a$ strebt bei konstanter Eingangsgrösse $x_e$ keinen stationären Endwert an. Es gibt folglich keine Kennlinie und keinen Proportionalbeiwert $K_P$.
Allerdings haben alle I-Glieder gemeinsam, dass die Ausgangsgrösse $x_a$ bei einer konstanten Eingangsgrösse $x_e$ schliesslich *linear* ansteigt (bzw. abfällt). Für eine gleichbleibende Eingangsgrösse $x_e$ resultiert also eine konstante Steigung der Ausgangsgrösse $\Delta x_a/\Delta t$. Eine sinnvolle Kenngrösse ist daher der **Integrierbeiwert** $K_I$, der die Steigung der Ausgangsgrösse bei stationärer Eingangsgrösse (Einheitssprung) beschreibt.
$$
K_I = \frac{\Delta x_a/\Delta t}{\Delta x_e} \quad \quad \quad \left(= \frac{1}{T_I} \right)
$$ {#eq-ki}
Der Kehrwert des Integrierbeiwerts wird als **Integrierzeit**[^integrierzeit] $T_I = \frac{1}{K_I}$ bezeichnet. In <span class="cap">Boris</span> werden wir üblicherweise mit der Integrierzeit $T_I$ arbeiten.
### I-Glied {.unnumbered}
Das (reine) I-Glied ist das einfachste Übertragungsglied ohne Ausgleich und weist keine Verzögerung auf. Es wird durch den Integrierbeiwert $K_I$ bzw. die Integrierzeit $T_I$ vollständig beschrieben.
$$
x_a(t) = K_I \cdot \int{x_e(t)\, \mathrm{d}t} = \frac{1}{T_I} \cdot \int{x_e(t)\, \mathrm{d}t}
$$
Wir erkennen in obiger Gleichung sehr schön, dass der Eingang *integriert* wird (daher kommt der Name *I-Glieder*). Leitet man beide Seiten der Gleichung ab, so resultiert die folgende äquivalente Differentialgleichung 1. Ordnung:
$$
\dot{x}_a(t) = K_I \cdot x_e(t)
$$
::: {#fig-I layout="[25,75]"}


I-Glied
:::
Ein typisches Beispiel für ein I-Glied ist die Linearachse, wenn als Eingang die Spindeldrehzahl und als Ausgang die Schlittenposition betrachtet wird. Allg. treten I-Glieder auf, wo eine Grösse durch Integration (Aufsummierung) in die entsprechende Speichergrösse überführt wird.
- Durchfluss (Volumenstrom) → Tankinhalt (Füllhöhe)
- Beschleunigung/Kraft → Geschwindigkeit
- Geschwindigkeit → Position (Weg)
- Drehzahl → Drehwinkel
- ...
::: {#fig-IBsp}
{width=60%}
Linearachse [Quelle](https://www.festo.com/ch/de/p/spindelachse-id_EGC_BS)
:::
### I-T~1~-Glied {.unnumbered}
Kommt beim I-Glied nun eine Verzögerung (Energiespeicher) hinzu, landen wir beim I-T~1~-Glied, für dessen Beschreibung neben $K_I$ (alternativ $T_I$) nun wiederum die Zeitkonstante $T_1$ nötig ist.
$$
T_1 \cdot \ddot{x}_a(t) + \dot{x}_a(t) = K_I \cdot x_e(t)
$$
::: {#fig-IT1 layout="[25,75]"}


I-T~1~-Glied
:::
Wird die in @fig-IBsp gezeigte Linearachse mit einem DC-Motor angetrieben (der als P-T~1~-Glied modelliert wird), stellt das Gesamtsystem ein I-T~1~-Glied dar. I-Strecken mit Verzögerungen sind in <span class="cap">Boris</span> nicht direkt verfügbar und müssen daher durch Reihenschaltungen erzeugt werden (ein I-T~1~-Glied z. B. durch eine Reihenschaltung von einem I-Glied und einem P-T~1~-Glied etc.).
### I-T~t~-Glied {.unnumbered}
Tritt eine Totzeit $T_t$ mit einem I-Glied auf, so sprechen wir von einem I-T~t~-Glied.
$$
\dot{x}_a(t) = K_I \cdot x_e(t - T_t)
$$
::: {#fig-ITt layout="[25,75]"}


I-T~t~-Glied
:::
Wir verzichten hier auf die Auflistung des I-T~2~-, I-T~2S~-, I-T~n~-Gliedes, da mittlerweile die Systematik klar sein sollte. Wie bei den P-Gliedern lassen sich die Zeitkonstanten bei I-Gliedern höherer Ordnung nicht direkt aus der Sprungantwort ablesen.
::: {.callout-note title="Tangente" #nte-wt-i}
Die Wendetangente (vgl. @nte-wt) bzw. die Ausgleichszeit $T_b$ existiert bei I-Gliedern nicht. Die Verzugszeit $T_e$ kann durch das Anlegen der Tangente an die Sprungantwort bestimmt werden.
{fig-align="center"}
:::
::: {.callout-note title="Reihenschaltung von Übertragungsgliedern"}
Ein I-T~2~-Glied kann als Reihenschaltung von einem I-Glied und einem P-T~2~-Glied (oder zwei P-T~1~-Gliedern) aufgefasst werden.
> Bsp.: In einer Regelstrecke werden das Stellglied als P-T~2~-Glied, die eigentliche Strecke als reines I-Glied und das Messglied als P-T~1~-Glied modelliert. Die gesamte Regelstrecke (Stellglied, Strecke, Messglied) weist dann I-T~3~-Verhalten auf.
:::
::: {.callout-tip}
## Übung
Erzeuge mit <span class="cap">Boris</span> die Sprungantwort für ein I-T~2~-Glied mit $K_I = 0.1$, $T_1 = 2$ und $T_2 = 0.5$.
:::
## Regelbarkeit
Wie man intuitiv vermuten würde, sind Verzögerungen höherer Ordnung (z. B. ein P-T~5~-Glied bzw. Totzeiten) für die Regelung deutlich ungünstiger als Verzögerungen niedriger Ordnung (z. B. ein P-T~1~). Mit zunehmender Verzögerung dauert es verhältnismässig immer länger bis eine Eingangsänderung am Ausgang "erscheint". Sehr ungünstig wird es, wenn (wie bei der Totzeit) der Ausgang verzögert ist und dann plötzlich rasch ansteigt. Dies ist für den Regler eine grosse Herausforderung, da er zuerst stark eingreift, weil am Ausgang noch nichts passiert, und dann rasch zurückfahren muss, wenn die Änderung am Ausgang schlagartig erscheint.
{#fig-verz-p}
Ein Mass, das die *Regelbarkeit* einer P-Strecke charakterisiert, ist das Verhältnis von Verzugs- zu Ausgleichszeit $\frac{T_e}{T_b}$. Für P- bzw. P-T~1~-ähnliche Strecken ist dieses Verhältnis sehr klein (~0), d. h. diese Strecken sind sehr einfach zu regeln. Mit zunehmender Ordnung bis hin zur Totzeit wird $\frac{T_e}{T_b}$ immer grösser und die Strecke immer schwieriger zu regeln.
{#fig-regelbarkeit}
::: {#tbl-regelbarkeit}
|$\dfrac{T_e}{T_b}$| Regelbarkeit |
|:---------------:|:---------------------|
|$< 0.1$ | sehr gut regelbar |
|$0.1 \ldots 0.2$ | gut regelbar |
|$0.2 \ldots 0.4$ | mässig regelbar |
|$0.4 \ldots 0.8$ | schwer regelbar |
|$> 0.8$ | sehr schwer regelbar |
Regelbarkeit
:::
Sinngemäss gilt dies auch für I-Strecken. Mit zunehmender Verzugszeit $T_e$ (reines I-Glied → I-T~1~ → I-T~2~ → ... → I-T~t~) wird es immer schwieriger für die Regelung.
{#fig-verz-i}
## Aufgaben {.unnumbered}
<button class="pdf-export"
data-target="aufgaben3"
data-filename="SYS_RE1_AUFG03.pdf"
aria-label="Aufgaben als PDF speichern"
title="Aufgaben als PDF speichern">
<img src="/images/icons/file-pdf.svg" alt="PDF herunterladen" width="24" height="24">
</button>
:::: {#aufgaben3}
::: {.callout-tip collapse="true" #ex-3-1}
### Aufgabe 3.1
Du hast eine Sprungantwort aufgenommen für einen Temperatursensor, indem du einen Temperatursprung von 20 °C auf 30 °C aufgeprägt (blau) und das Spannungssignal des Sensors gemessen hast (rot).

(a) Bestimme den Proportionalbeiwert $K_P$ aus der Sprungantwort (inkl. Einheit).
$$
K_P =
$$
(b) Bestimme die Zeitkonstante $T_1$ aus der Sprungantwort (inkl. Einheit).
$$
T_1 =
$$
(c) Um was für ein Grundglied handelt es sich dabei?
:::: {.callout-important collapse="true"}
### Lösung

(a) Der Proportionalbeiwert $K_P$ entspricht der Änderung des Ausgangssignals dividiert durch die Änderung des Eingangssignals.
$$
K_P = \frac{\Delta U}{\Delta \vartheta} = \frac{6\,\mathrm{V}-4\,\mathrm{V}}{30\,\mathrm{°C}-20\,\mathrm{°C}} = \frac{2\,\mathrm{V}}{10\,\mathrm{°C}} = 0.2\frac{\mathrm{V}}{\mathrm{°C}}
$$
(b) Die Zeitkonstante $T_1$ wird mittels Tangente bzw. 63%-Anstiegszeit bestimmt.
$$
T_1 = 1.5\,\mathrm{s}
$$
(c) P-T~1~
::::
:::
::: {.callout-tip collapse="true" #ex-3-2}
### Aufgabe 3.2
Die nachfolgend abgebildete Lineareinheit (Positioniereinheit mit Spindel) soll für eine spätere Regelung untersucht werden. Betrachtet man die Spindeldrehzahl $𝑛$ als Eingang und die Schlittenposition $𝑥$ als Ausgang, so stellt das System ein I-Glied dar. Die Gewindesteigung der Spindel beträgt 5 mm.

(a) Skizziere den zeitlichen Verlauf der Schlittenposition $𝑥$ für die ersten 5 s im
untenstehenden Diagramm für eine Spindeldrehzahl $𝑛$ von 1 Umdrehung pro Sekunde.
(Annahme: Position $𝑥 = 0$ bei $𝑡 = 0$).

(b) Ermittle den Integrierbeiwert $K_I$ bzw. die Integrierzeit $T_I$ (rechnerisch oder grafisch).
$$
K_I = \quad \quad \quad \quad T_I =
$$
(c) Simuliere die Sprungantwort der obigen I-Strecke in <span class="cap">Boris</span>. Stelle die Simulationsdauer dabei auf 5 Sekunden.
:::: {.callout-important collapse="true"}
### Lösung
(a) Die Änderung der Schlittenposition $x$ pro Umdrehung entspricht der Steigung der Gewindespindel (=5 mm). Bei einer Drehzahl von 1 Umdrehung pro Sekunde ergibt das eine Positionsänderung von 5 mm/s.

(b) Der Integrierbeiwert $K_I$ entspricht der Steigung der Sprungantwort (bezogen auf das Eingangssignal). Der Kehrwert davon ist $T_I$ und wird Integrierzeit genannt. Die Integrierzeit entspricht der Zeitdauer bis zum Erreichen des Wertes 1.
$$
K_I = \frac{\Delta x}{\Delta t \cdot \Delta n} = \frac{5\,\mathrm{mm}}{1\,\mathrm{s}\cdot1\,\frac{1}{\mathrm{s}}} = 5\,\mathrm{mm} \quad \quad T_I = \frac{1}{K_I} = 0.2\,\frac{1}{\mathrm{mm}}
$$
(c) Die Simulation in <span class="cap">Boris</span> ist straight-forward. Zu beachten ist, dass beim I-Glied die Integrierzeit $T_I$ eingegeben werden muss (und nicht der Integrierbeiwert $K_I$).
::: {layout-ncol=2}


:::
::::
:::
::: {.callout-tip collapse="true" #ex-3-3}
### Aufgabe 3.3
Bestimme Verzugszeit $T_e$ und Ausgleichszeit $T_b$ aus der Sprungantwort des nachfolgend abgebildeten Übertragungsgliedes (vgl. @nte-wt). Berechne anschliessend das Verhältnis $T_e/T_b$ und beurteile die Regelbarkeit des Systems.

$$
T_e =
$$
$$
T_b =
$$
$$
\frac{T_e}{T_b} =
$$
:::: {.callout-important collapse="true"}
### Lösung

$$
T_e \approx 1\,\mathrm{s}
$$
$$
T_b \approx 7\,\mathrm{s}-1\,\mathrm{s} = 6\,\mathrm{s}
$$
$$
\frac{T_e}{T_b} = \frac{1\,\mathrm{s}}{6\,\mathrm{s}} = 0.17\,\mathrm{s}
$$
Damit ist die Regelstrecke gemäss @tbl-regelbarkeit noch *gut regelbar*.
::::
:::
::::
[^integrierzeit]: Die Integrierzeit $T_I$ hat je nach Einheit der Ein- und Ausgangsgrösse eine andere Einheit. Nur wenn Ein- und Ausgangsgrösse die gleiche Einheit haben, hat $T_I$ eine Zeiteinheit (z. B. [s]).