# Streckenidentifikation {#sec-id}
Der zweite Schritt des regelungstechnischen Workflows (vgl. @fig-workflow) befasst sich mit der Modellierung der Regelstrecke, d. h. wir müssen Verfahren kennen, um eine reale Regelstrecke z. B. anhand einer Messung der Sprungantwort in der Simulation nachbilden zu können.
::: {.callout-important title="Ziele"}
- Du kennst Methoden, um eine reale Regelstrecke anhand der Sprungantwort zu charakterisieren bzw. modellieren → **Experimentelle Identifikation** der Regelstrecke.
:::
Bei einfachen Strecken (z. B. P-T~1~, P-T~t~, I, I-T~1~, ...) können wir sämtliche Parameter direkt aus der Sprungantwort ablesen, d. h. im Folgenden geht es primär um Strecken höherer Ordnung (P-T~2~, P-T~3~, usw.), wo dies nicht möglich ist.
::: {.callout-note title="Modellierung"}
Ein Modell ist immer eine vereinfachte Abbildung der Realität und wird immer mehr oder weniger von der realen Regelstrecke abweichen. In vielen Fällen reicht ein ungefähres Modell völlig aus, da die Regelung ohnehin eine gewisse Robustheit aufweisen muss, sodass kleine Abweichungen bei der Modellierung toleriert werden können.
:::
## Verfahren nach Küpfmüller
Beim Verfahren nach *Küpfmüller* wird die Strecke als **P-T~1~-T~t~**-Glied modelliert, wobei die Werte für $T_t$ und $T_1$ anhand der *Wendetangente* (vgl. @nte-wt) bestimmt werden.
{#fig-kuepfmueller}
$$
T_t = T_e
$$
$$
T_1 = T_b
$$
Das *Küpfmüller*-Verfahren ist sehr einfach anzuwenden, liefert jedoch häufig suboptimale Ergebnisse. Wie in @fig-kuepfmueller ersichtlich ist, liegt die modellierte Sprungantwort z. T. deutlich unterhalb der gemessenen.
## Verfahren nach Strejc
Das Verfahren nach *Strejc* geht ebenfalls von einem **P-T~1~-T~t~**-Modell aus und liefert generell bessere Ergebnisse als das *Küpfmüller-Verfahren*. Es fordert, dass die Sprungantworten in mindestens zwei Punkten ($A$ und $B$) exakt übereinstimmen. Häufig werden dafür die Punkte verwendet, bei denen 10% bzw. 90% des stationären Endwertes erreicht sind, es können aber auch andere Punkte gewählt werden. Für die Herleitung wird auf @crashkurs verwiesen und hier lediglich die relevanten Beziehungen aufgeführt.
{#fig-strejc}
$$
T_t = \frac{t_B \ln{\left(1 - \frac{x_A}{x_\infty} \right)} - t_A \ln{\left(1 - \frac{x_B}{x_\infty} \right)}}{\ln{\left(1 - \frac{x_A}{x_\infty} \right)} - \ln{\left(1 - \frac{x_B}{x_\infty} \right)}}
$$
$$
T_1 = - \frac{t_A - T_t}{\ln{\left(1 - \frac{x_A}{x_\infty} \right)}}
$$
Die obigen Beziehungen sehen kompliziert aus, da sie für eine beliebige Wahl von $A$ und $B$ geschrieben wurden. Wählt man für $A$ den 10%- bzw. für $B$ den 90%-Punkt, so ergeben sich folgende Beziehungen.
$$
T_t = \frac{t_B \ln(0.9) - t_A \ln(0.1)}{\ln(0.9) - \ln(0.1)} = \frac{2.303 \cdot t_A - 0.105 \cdot t_B}{2.197}
$$
$$
T_1 = - \frac{t_A - T_t}{\ln(0.9)} = \frac{t_A - T_t}{0.105}
$$
<!-- Strejc-Verfahren interaktiv -->
```{=html}
<div style="display:flex;align-items:flex-start;gap:2em;border:1px solid #ccc;border-radius:6px;padding:0.6em 1.1em;margin:1em 0;font-family:'Source Sans Pro',sans-serif;">
<div style="display:flex;flex-direction:column;gap:0.5em;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:5em;">x_A\ [\%]</span>
<input id="st-xa" type="number" step="any" min="0" max="100" class="calc-field calc-pos" value="10">
<span class="math inline" style="display:inline-block;width:3em;margin-left:3em;">t_A</span>
<input id="st-ta" type="number" step="any" min="0" class="calc-field calc-pos">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:5em;">x_B\ [\%]</span>
<input id="st-xb" type="number" step="any" min="0" max="100" class="calc-field calc-pos" value="90">
<span class="math inline" style="display:inline-block;width:3em;margin-left:3em;">t_B</span>
<input id="st-tb" type="number" step="any" min="0" class="calc-field calc-pos">
</div>
</div>
<div style="display:flex;flex-direction:column;gap:0.5em;margin-left:auto;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:4em;">T_t</span>
<input id="st-Tt" type="text" readonly class="calc-field">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:4em;">T_1</span>
<input id="st-T1" type="text" readonly class="calc-field">
</div>
</div>
</div>
<script>
(function () {
var xa = document.getElementById("st-xa");
var ta = document.getElementById("st-ta");
var xb = document.getElementById("st-xb");
var tb = document.getElementById("st-tb");
var outTt = document.getElementById("st-Tt");
var outT1 = document.getElementById("st-T1");
function fmt(v) {
if (!isFinite(v)) return "\u2013";
var f = Math.round(v * 1e5) / 1e5;
return String(f);
}
function clamp(el, lo, hi) {
if (el.value === "") return;
var n = Number(el.value);
if (!isFinite(n)) { el.value = ""; return; }
if (n < lo) el.value = lo;
else if (n > hi) el.value = hi;
}
function update() {
var a = parseFloat(xa.value);
var b = parseFloat(ta.value);
var c = parseFloat(xb.value);
var d = parseFloat(tb.value);
if (isNaN(a) || isNaN(b) || isNaN(c) || isNaN(d) || a <= 0 || c <= 0 || a >= 100 || c >= 100) {
outTt.value = fmt(NaN);
outT1.value = fmt(NaN);
return;
}
var la = Math.log(1 - a / 100);
var lb = Math.log(1 - c / 100);
var Tt = (d * la - b * lb) / (la - lb);
var T1 = -(b - Tt) / la;
outTt.value = fmt(Tt);
outT1.value = fmt(T1);
}
ta.addEventListener("input", update);
tb.addEventListener("input", update);
xa.addEventListener("input", function () { clamp(this, 0, 100); update(); });
xb.addEventListener("input", function () { clamp(this, 0, 100); update(); });
[xa, ta, xb, tb].forEach(function (el) {
el.addEventListener("beforeinput", function (e) {
if (e.data && e.data.indexOf("-") !== -1) e.preventDefault();
});
});
update();
})();
</script>
```
## Verfahren nach Ormanns
Das Verfahren von *Ormanns* legt ein **P-T~2~**-Modell zugrunde. Dabei werden die beiden Zeitpunkte $t_{30\%}$ bzw. $t_{70\%}$ bestimmt, d. h. die Zeitpunkte, an denen die Sprungantwort 30% bzw. 70% des stationären Endwertes erreicht hat.
{#fig-ormanns}
Die beiden Zeitkonstanten $T_1$ bzw. $T_2$ für das P-T~2~-Modell ergeben sich dann zu:
$$
T_1 = 0.5 \cdot \left(\frac{t_{70\%}}{1.2} + \frac{t_{30\%}+t_{70\%}}{0.6} \cdot \sqrt{0.45-\frac{t_{30\%}}{t_{70\%}}} \right)
$$
$$
T_2 = \frac{t_{70\%}}{1.2} - T_1
$$
Das Verfahren ist nur anwendbar, wenn $\dfrac{t_{30\%}}{t_{70\%}} < 0.45$.
```{=html}
<div style="display:flex;align-items:flex-start;gap:2em;border:1px solid #ccc;border-radius:6px;padding:0.6em 1.1em;margin:1em 0;font-family:'Source Sans Pro',sans-serif;">
<div style="display:flex;flex-direction:column;gap:0.5em;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:6em;">t_{30\%}</span>
<input id="orm-t30" type="number" step="any" min="0" class="calc-field calc-pos">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:6em;">t_{70\%}</span>
<input id="orm-t70" type="number" step="any" min="0" class="calc-field calc-pos">
<span id="orm-warn" style="display:none;color:#b71c1c;font-size:12px;">Verfahren nicht anwendbar</span>
</div>
</div>
<div style="display:flex;flex-direction:column;gap:0.5em;margin-left:auto;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:3em;">T_1</span>
<input id="orm-T1" type="text" readonly class="calc-field">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:3em;">T_2</span>
<input id="orm-T2" type="text" readonly class="calc-field">
</div>
</div>
</div>
<script>
(function () {
var t30 = document.getElementById("orm-t30");
var t70 = document.getElementById("orm-t70");
var outT1 = document.getElementById("orm-T1");
var outT2 = document.getElementById("orm-T2");
var warn = document.getElementById("orm-warn");
function fmt(v) {
if (isNaN(v)) return "\u2013";
var f = Math.round(v * 1e5) / 1e5;
return String(f);
}
function update() {
var a = parseFloat(t30.value);
var b = parseFloat(t70.value);
if (isNaN(a) || isNaN(b) || b <= 0) {
warn.style.display = "none";
outT1.value = fmt(NaN);
outT2.value = fmt(NaN);
return;
}
var ratio = a / b;
if (ratio >= 0.45) {
warn.style.display = "inline";
outT1.value = fmt(NaN);
outT2.value = fmt(NaN);
} else {
warn.style.display = "none";
var T1 = 0.5 * (b / 1.2 + (a + b) / 0.6 * Math.sqrt(0.45 - ratio));
var T2 = b / 1.2 - T1;
outT1.value = fmt(T1);
outT2.value = fmt(T2);
}
}
t30.addEventListener("input", update);
t70.addEventListener("input", update);
[t30, t70].forEach(function (el) {
el.addEventListener("beforeinput", function (e) {
if (e.data && e.data.indexOf("-") !== -1) e.preventDefault();
});
el.addEventListener("input", function () {
if (this.value !== "" && Number(this.value) < 0) this.value = "";
});
});
update();
})();
</script>
```
## Wendentangentenverfahren {#sec-wtv}
Beim *Wendetangentenverfahren* wird ebenfalls ein **P-T~2~**-Modellansatz verwendet. Die beiden Modellzeitkonstanten $T_1$ bzw. $T_2$ werden dabei aus den Ersatzzeitkonstanten $T_e$ (Verzugszeit) bzw. $T_b$ (Ausgleichszeit) bestimmt (vgl. @nte-wt).
{#fig-wt}
Dabei wird folgendermassen vorgegangen, wobei @tbl-wt benötigt wird:
1) Verhältnis $T_b / T_e$ ermitteln und die entsprechende Zeile in der 3. Spalte bestimmen. Falls keine Zeile direkt passt, muss gegebenenfalls interpoliert werden.
2) Mit dem Wert aus der 2. Spalte kann dann $T_1$ bestimmt werden.
3) Mit dem Wert aus der 1. Spalte kann schliesslich $T_2$ bestimmt werden.
::: {#tbl-wt}
| $T_2 / T_1$ | $T_b / T_1$ | $T_b / T_e$ |
|:--------:|:-----:|:-----:|
| 0.10 | 1.29 | 20.09 |
| 0.20 | 1.50 | 13.97 |
| 0.30 | 1.68 | 11.91 |
| 0.40 | 1.84 | 10.91 |
| 0.50 | 2.00 | 10.35 |
| 0.60 | 2.15 | 10.03 |
| 0.70 | 2.30 | 9.83 |
| 0.80 | 2.44 | 9.72 |
| 0.90 | 2.58 | 9.66 |
| 0.99 | 2.70 | 9.65 |
Wendetangentenverfahren
:::
Das Verfahren ist anwendbar für $\dfrac{T_b}{T_e} \geq 9.64$.
```{=html}
<div style="display:flex;align-items:flex-start;gap:2em;border:1px solid #ccc;border-radius:6px;padding:0.6em 1.1em;margin:1em 0;font-family:'Source Sans Pro',sans-serif;">
<div style="display:flex;flex-direction:column;gap:0.5em;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:6em;">T_b</span>
<input id="wt-tb" type="number" step="any" min="0" class="calc-field calc-pos">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:6em;">T_e</span>
<input id="wt-te" type="number" step="any" min="0" class="calc-field calc-pos">
<span id="wt-warn" style="display:none;color:#b71c1c;font-size:12px;">Verfahren nicht anwendbar</span>
</div>
</div>
<div style="display:flex;flex-direction:column;gap:0.5em;margin-left:auto;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:3em;">T_1</span>
<input id="wt-T1" type="text" readonly class="calc-field">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:3em;">T_2</span>
<input id="wt-T2" type="text" readonly class="calc-field">
</div>
</div>
</div>
<script>
(function () {
var tb = document.getElementById("wt-tb");
var te = document.getElementById("wt-te");
var outT1 = document.getElementById("wt-T1");
var outT2 = document.getElementById("wt-T2");
var warn = document.getElementById("wt-warn");
var wt = [
{ r: 20.09, x: 0.10, y: 1.29 },
{ r: 13.97, x: 0.20, y: 1.50 },
{ r: 11.91, x: 0.30, y: 1.68 },
{ r: 10.91, x: 0.40, y: 1.84 },
{ r: 10.35, x: 0.50, y: 2.00 },
{ r: 10.03, x: 0.60, y: 2.15 },
{ r: 9.83, x: 0.70, y: 2.30 },
{ r: 9.72, x: 0.80, y: 2.44 },
{ r: 9.66, x: 0.90, y: 2.58 },
{ r: 9.65, x: 0.99, y: 2.70 }
];
function fmt(v) {
if (isNaN(v)) return "\u2013";
var f = Math.round(v * 1e5) / 1e5;
return String(f);
}
function interp(R) {
if (R >= wt[0].r) return { x: wt[0].x, y: wt[0].y };
for (var i = 0; i < wt.length - 1; i++) {
if (R <= wt[i].r && R >= wt[i + 1].r) {
var t = Math.min(1, Math.max(0, (wt[i].r - R) / (wt[i].r - wt[i + 1].r)));
return {
x: wt[i].x + t * (wt[i + 1].x - wt[i].x),
y: wt[i].y + t * (wt[i + 1].y - wt[i].y)
};
}
}
return { x: wt[wt.length - 1].x, y: wt[wt.length - 1].y };
}
function update() {
var a = parseFloat(tb.value);
var b = parseFloat(te.value);
if (isNaN(a) || isNaN(b) || b <= 0) {
warn.style.display = "none";
outT1.value = fmt(NaN);
outT2.value = fmt(NaN);
return;
}
var R = a / b;
if (R < 9.64) {
warn.style.display = "inline";
outT1.value = fmt(NaN);
outT2.value = fmt(NaN);
} else {
warn.style.display = "none";
var v = interp(R);
var T1 = a / v.y;
var T2 = T1 * v.x;
outT1.value = fmt(T1);
outT2.value = fmt(T2);
}
}
tb.addEventListener("input", update);
te.addEventListener("input", update);
[tb, te].forEach(function (el) {
el.addEventListener("beforeinput", function (e) {
if (e.data && e.data.indexOf("-") !== -1) e.preventDefault();
});
el.addEventListener("input", function () {
if (this.value !== "" && Number(this.value) < 0) this.value = "";
});
});
update();
})();
</script>
```
::: {.callout-note title="Wendetangentenverfahren"}
Dieses Verfahren ist in abgewandelter Form in <span class="cap">Boris</span> implementiert, und zwar im **T~e~-T~b~-Block**. Dabei werden $T_e$ und $T_b$ eingegeben und es werden automatisch $T_1$ und $T_2$ des P-T~2~-Gliedes bestimmt. Wird die Bedingung $\frac{T_b}{T_e} \geq 9.64$ nicht eingehalten, wird zusätzlich eine Totzeit eingefügt bis die Bedingung erfüllt ist. Der **T~e~-T~b~-Block** weist also P-T~2~- oder P-T~2~-T~t~-Verhalten auf.
:::
## Verfahren der Zeitprozentkennwerte {#sec-zpkw}
Beim Verfahren der *Zeitprozentkennwerte* wird ein **P-T~n~**-Modell zugrunde gelegt mit $n$ identischen Zeitkonstanten $T_1, \dots, T_n$. Es basiert auf den Zeitpunkten $t_{10\%}$, $t_{50\%}$ bzw. $t_{90\%}$, d. h. den Zeitpunkten, bei denen die Sprungantwort 10%, 50% bzw. 90% des stationären Endwertes erreicht hat.
{#fig-zeitprozentkennwerte}
Dabei wird folgendermassen vorgegangen, wobei @tbl-zpkw benötigt wird:
1) Zeitwerte $t_{10\%}$, $t_{50\%}$ sowie $t_{90\%}$ ermitteln und damit den Parameter $\mu = \dfrac{t_{10\%}}{t_{90\%}}$ berechnen.
2) Mit dem Wert $\mu$ die Zeile ermitteln, die am besten passt, und darin die Werte für $n$ und $\alpha_{10}$, $\alpha_{50}$ bzw. $\alpha_{90}$ ablesen.
3) Die Zeitkonstanten $T_1, \dots, T_n$ gemäss nachfolgender Beziehung berechnen.
$$
T_1, \dots, T_n = \frac{1}{3} \left( \alpha_{10} \cdot t_{10\%} + \alpha_{50} \cdot t_{50\%} + \alpha_{90} \cdot t_{90\%} \right)
$$
::: {#tbl-zpkw}
| $\mu$ | $n$ | $\alpha_{10}$ | $\alpha_{50}$ | $\alpha_{90}$ |
|:-----:|:--:|:----:|:----:|:----:|
| 0.046 | 1 | 9.491 | 0.1443 | 0.434 |
| 0.137 | 2 | 1.880 | 0.596 | 0.257 |
| 0.207 | 3 | 0.907 | 0.374 | 0.188 |
| 0.261 | 4 | 0.573 | 0.272 | 0.150 |
| 0.304 | 5 | 0.411 | 0.214 | 0.125 |
| 0.340 | 6 | 0.317 | 0.176 | 0.108 |
| 0.370 | 7 | 0.257 | 0.150 | 0.095 |
| 0.396 | 8 | 0.215 | 0.130 | 0.085 |
| 0.418 | 9 | 0.184 | 0.115 | 0.077 |
| 0.438 | 10 | 0.161 | 0.103 | 0.070 |
Verfahren der Zeitprozentkennwerte
:::
```{=html}
<div style="display:flex;align-items:flex-start;gap:2em;border:1px solid #ccc;border-radius:6px;padding:0.6em 1.1em;margin:1em 0;font-family:'Source Sans Pro',sans-serif;">
<div style="display:flex;flex-direction:column;gap:0.5em;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:6em;">t_{10\%}</span>
<input id="zp-t10" type="number" step="any" min="0" class="calc-field calc-pos">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:6em;">t_{50\%}</span>
<input id="zp-t50" type="number" step="any" min="0" class="calc-field calc-pos">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:6em;">t_{90\%}</span>
<input id="zp-t90" type="number" step="any" min="0" class="calc-field calc-pos">
<span id="zp-warn" style="display:none;color:#b71c1c;font-size:12px;">Verfahren nicht anwendbar</span>
</div>
</div>
<div style="display:flex;flex-direction:column;gap:0.5em;margin-left:auto;">
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:5em;">n</span>
<input id="zp-n" type="text" readonly class="calc-field">
</div>
<div style="display:flex;align-items:center;gap:0.6em;white-space:nowrap;">
<span class="math inline" style="display:inline-block;width:5em;">T_1, \dots, T_n</span>
<input id="zp-T" type="text" readonly class="calc-field">
</div>
</div>
</div>
<script>
(function () {
var t10 = document.getElementById("zp-t10");
var t50 = document.getElementById("zp-t50");
var t90 = document.getElementById("zp-t90");
var outN = document.getElementById("zp-n");
var outT = document.getElementById("zp-T");
var warn = document.getElementById("zp-warn");
var zp = [
{ mu: 0.046, n: 1, a10: 9.491, a50: 0.1443, a90: 0.434 },
{ mu: 0.137, n: 2, a10: 1.880, a50: 0.596, a90: 0.257 },
{ mu: 0.207, n: 3, a10: 0.907, a50: 0.374, a90: 0.188 },
{ mu: 0.261, n: 4, a10: 0.573, a50: 0.272, a90: 0.150 },
{ mu: 0.304, n: 5, a10: 0.411, a50: 0.214, a90: 0.125 },
{ mu: 0.340, n: 6, a10: 0.317, a50: 0.176, a90: 0.108 },
{ mu: 0.370, n: 7, a10: 0.257, a50: 0.150, a90: 0.095 },
{ mu: 0.396, n: 8, a10: 0.215, a50: 0.130, a90: 0.085 },
{ mu: 0.418, n: 9, a10: 0.184, a50: 0.115, a90: 0.077 },
{ mu: 0.438, n: 10, a10: 0.161, a50: 0.103, a90: 0.070 }
];
function fmt(v) {
if (isNaN(v)) return "\u2013";
var f = Math.round(v * 1e5) / 1e5;
return String(f);
}
function nearest(mu) {
var best = zp[0], bestDist = Math.abs(zp[0].mu - mu);
for (var i = 1; i < zp.length; i++) {
var d = Math.abs(zp[i].mu - mu);
if (d < bestDist) { bestDist = d; best = zp[i]; }
}
return best;
}
function update() {
var a = parseFloat(t10.value);
var b = parseFloat(t50.value);
var c = parseFloat(t90.value);
if (isNaN(a) || isNaN(b) || isNaN(c) || c <= 0) {
warn.style.display = "none";
outN.value = fmt(NaN);
outT.value = fmt(NaN);
return;
}
var mu = a / c;
if (mu < 0.046 || mu > 0.438) {
warn.style.display = "inline";
outN.value = fmt(NaN);
outT.value = fmt(NaN);
} else {
warn.style.display = "none";
var row = nearest(mu);
var T = (row.a10 * a + row.a50 * b + row.a90 * c) / 3;
outN.value = String(row.n);
outT.value = fmt(T);
}
}
t10.addEventListener("input", update);
t50.addEventListener("input", update);
t90.addEventListener("input", update);
[t10, t50, t90].forEach(function (el) {
el.addEventListener("beforeinput", function (e) {
if (e.data && e.data.indexOf("-") !== -1) e.preventDefault();
});
el.addEventListener("input", function () {
if (this.value !== "" && Number(this.value) < 0) this.value = "";
});
});
update();
})();
</script>
```
## Numerische Optimierungsverfahren
Neben den oben aufgeführten "manuellen" Verfahren können die Parameter einer Regelstrecke auch mittels numerischer Optimierung bestimmt werden. Dazu werden Optimierungsalgorithmen verwendet, die im Allg. eine Zielfunktion minimieren (d. h. in unserem Fall wird die Differenz zwischen dem Modell und der Messung minimiert, indem die Parameter variiert werden, bis eine optimale Lösung gefunden wurde).
$$
\min_{K_P, T_1, \ldots} \, \left\| x_{\mathrm{Modell}} - x_{\mathrm{Messung}} \right\|
$$
{#fig-opt}
Wir werden solche Methoden nicht weiter anschauen, da sie in der Praxis häufig nicht notwendig sind. Obwohl in <span class="cap">Boris</span> gewisse Werkzeuge integriert sind, würde man solche Optimierungen vorzugsweise mit <span class="cap">Python</span> oder einem vergleichbaren Tool umsetzen.
## Identifikation von Strecken ohne Ausgleich (I-Strecken)
Oben wurden ausschliesslich P-Strecken betrachtet, doch die Verfahren funktionieren auch für I-Strecken. Wird die Sprungantwort einer I-Strecke abgeleitet (differenziert), so wird der I-Anteil abgespalten und es verbleibt eine P-Strecke, wobei allfällige Verzögerungen nicht verändert werden. Damit können die obigen Verfahren angewendet werden.
{#fig-id-i}
Der so bestimmte Proportionalbeiwert $K_P$ für die Strecke ohne I-Anteil entspricht gerade dem Integrierbeiwert $K_I$ der Originalstrecke.
::: {.callout-note title="D-Glied"}
Die Ableitung kann in <span class="cap">Boris</span> mit dem D-Glied (D für Differenzierung) erfolgen.
{width=20% fig-align="center"}
:::
## Aufgaben {.unnumbered}
<button class="pdf-export"
data-target="aufgaben4"
data-filename="SYS_RE1_AUFG04.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>
:::: {#aufgaben4}
::: {.callout-tip collapse="true" #ex-4-1}
### Aufgabe 4.1
Identifiziere die nachfolgend abgebildete Sprungantwort anhand des *Wendentangentenverfahrens* (vgl. @sec-wtv bzw. Kap. 2.4.5 in @crashkurs). Bestimme die beiden Zeitkonstanten $T_1$ und $T_2$.

(a) Führe das Verfahren "manuell" durch gemäss @sec-wtv.
(b) Verwende den **T~e~-T~b~-Block** in <span class="cap">Boris</span>.
:::: {.callout-important collapse="true"}
### Lösung
(a) manuell

Schritt 1: $T_e$ und $T_b$ bestimmen und dann mit dem Verhältnis $T_b/T_e$ in der @tbl-wt die passende Zeile in der 3. Spalte bestimmen.
$$
T_e \approx 2\,\mathrm{s} \quad \quad T_b \approx 20\,\mathrm{s}
$$
$$
\frac{T_b}{T_e} = \frac{20}{2} = 10
$$
Damit wählen wir die 6. Zeile in @tbl-wt (10.03).
Schritt 2: Mit dem Wert aus der 2. Spalte (2.15) kann nun $T_1$ bestimmt werden.
$$
\frac{T_b}{T_1} = 2.15 \quad \to \quad T_1 = \frac{T_b}{2.15} = \frac{20\,\mathrm{s}}{2.15} = 9.3\,\mathrm{s}
$$
Schritt 3: Mit dem Wert aus der 1. Spalte (0.6) kann schliesslich $T_2$ bestimmt werden.
$$
\frac{T_2}{T_1} = 0.6 \quad \to \quad T_2 = 0.6 \cdot T_1 = 0.6 \cdot 9.3\,\mathrm{s} = 5.6\,\mathrm{s}
$$
Damit haben wir die beiden Zeitkonstanten $T_1 = 9.3\,\mathrm{s}$ bzw. $T_2 = 5.6\,\mathrm{s}$ bestimmt. Zusätzlich kann der Proportionalbeiwert $K_P = 2.5$ direkt abgelesen werden und damit ist das Übertragungsglied vollständig identifiziert. (Zum Vergleich: Die wahren Zeitkonstanten sind $T_1 = 9.1\,\mathrm{s}$ bzw. $T_2 = 5.8\,\mathrm{s}$.)
(b) <span class="cap">Boris</span>
Im **T~e~-T~b~-Block** können $T_e$ (Verzugszeit) bzw. $T_b$ (Ausgleichszeit) direkt eingegeben werden und intern werden die beiden Zeitkonstanten $T_1$ und $T_2$ anhand des Wendetangentenverfahrens ermittelt. Es sollten also grob dieselben Werte wie oben resultieren.
::: {layout-ncol=2}


:::
::::
:::
::: {.callout-tip collapse="true" #ex-4-2}
### Aufgabe 4.2
Untenstehend ist eine Sprungantwort eines realen Systems als Textdatei gegeben, die mit dem Block *Tabellen-Eingabedatei* (aus der Palette *Quellen*) in <span class="cap">Boris</span> eingelesen werden kann.
(Eingangs- und Ausgangssignal in [V])
<a href="../assets/A4_2.TXT" download>
Sprungantwort-Messung der Regelstrecke (.txt)
</a>
Versuche das System durch ein P-T~n~-Glied mit $n$ gleichen Zeitkonstanten zu approximieren, indem du das *Verfahren der Zeitprozentkennwerte* (vgl. @sec-zpkw bzw. Kap. 2.4.6 in @crashkurs) anwendest. Gib die Ordnung $n$ und den Wert für die $n$ identischen Zeitkonstanten $T_1, .., T_n$ an.
:::: {.callout-important collapse="true"}
### Lösung
Für das Zeitprozentkennwerte-Verfahren benötigen wir als erstes die Zeitwerte $t_{10\%}$, $t_{50\%}$ sowie $t_{90\%}$, die wir aus der eingelesenen Sprungantwort ablesen können.

$$
t_{10\%} \approx 1.7\,\mathrm{s} \quad t_{50\%} \approx 4.0\,\mathrm{s} \quad t_{90\%} \approx 8.1\,\mathrm{s}
$$
Schritt 1: Parameter $\mu=t_{10\%}/t_{90\%}$ bestimmen.
$$
\mu = \frac{t_{10\%}}{t_{90\%}} = \frac{1.7\,\mathrm{s}}{8.1\,\mathrm{s}} = 0.21
$$
Schritt 2: Wir wählen die 3. Zeile ($\mu=0.207$) und erhalten $n = 3$, $\alpha_{10} =0.907$, $\alpha_{50} =0.374$ sowie $\alpha_{90} =0.188$.
Schritt 3: Nun können die Zeitkonstanten $T_1, \dots, T_n$ bestimmt werden.
$$
\begin{aligned}
T_1, \dots, T_n &= \frac{1}{3} \left( \alpha_{10} \cdot t_{10\%} + \alpha_{50} \cdot t_{50\%} + \alpha_{90} \cdot t_{90\%} \right) \\
&= \frac{1}{3} \left( 0.907 \cdot 1.7\,\mathrm{s} + 0.374 \cdot 4.0\,\mathrm{s} + 0.188 \cdot 8.1\,\mathrm{s} \right) \\
&= 1.52\,\mathrm{s}
\end{aligned}
$$
Es resultiert also ein P-T~3~ mit dem Proportionalbeiwert $K_P = 8$ und den Zeitkonstanten $T_1 = T_2 = T_3 = 1.52\,\mathrm{s}$.
::::
:::
::::