So baue ich ein digitales Differenzierglied.

[Armin (Gast)]

Problemstellung
Es ist ohne Weiteres möglich ein zeitdiskretes Signal (Wertefolge, die 
in gleichmäßigen Abständen gemessen wird), zu differenzieren. Meistens 
allerdings braucht man diese Ableitung aber "sofort" also "on-the-fly" 
und nicht erst, wenn das komplette Signal eingelesen ist.
Hier also ein kleines How-To, wie man sich ein Differenzierglied 
beliebiger Genauigkeit baut.

Theorie
Die Theorie erfordert Grundlagenwissen Regelungstechnik & Mathematik:
Laplace-Transformation, z-Transformation, evtl. Tustin-Transformation, 
Übertragungsfuntkion, realisierbare Übertragungsglieder, 
Approximationsverfahren (speziell Padé-Approximation), ...
und wird möglichst klein gehalten.

Namenskonvention
Der Algorithmus zur Berechnung der Ableitung wird auf ein periodisch 
digitalisiertes Analogsignal angewandt. Diese Periode hat den Wert T. 
Durch einen großen Algorithmus steigt vermutlich T, da die nötige 
Berechnungszeit steigt.

Das kleinste denkbare Differenzierglied lautet y[k] = 1/T(u[k] - u[k-1]) 
und wird hier nur kurz für die Namenskonvention betrachtet. y[k] 
bezeichnet den Ausgang des Differenzierers, u[k] den aktuellen 
Eingangswert. Der vorige Eingangswert u[k-1] muss in einer Variable 
zwischengespeichert werden, die für den nächsten Schritt mit dem 
aktuellen Eingangswert überschrieben werden kann. In Pseudocode:

int u_k1 = 0;
do
{
  y = (u - u_k1)/T;
  u_k1 = u;
}

Praxis
- Man wählt eine Ordnung n. Der Algorithmus wird 2n Speicherplätze für 
Vergangenheitswerte benötigen.
- Man setzt den Wert für n in diese URL ein und lässt sich die 
Padé-Approximation für ein Differenzierglied berechnen:
http://www.wolframalpha.com/input/?i=PadeApproximant[-Log[x],+{x,+1,+n}]
- dieser Bruch wird nun aufgelöst, dass er folgende Form hat:

$$\frac{a_n x^n+a_{n-1} x^{n-1}+\cdots +a_1x+a_0}{b_n x^n+b_{n-1} x^{n-1}+\cdots +b_1x+b_0}$$

, wobei b0 = 1 vorgegeben ist.
- dieser Bruch wird mit 1 gleichgesetzt und Nenner nach "Links" 
multipliziert

$$b_n x^n+b_{n-1} x^{n-1}+\cdots +b_1x+1 = a_n x^n+a_{n-1} x^{n-1}+\cdots +a_1x+a_0$$

- auf der Linken Seite bedeutet nun x^n soviel wie y[k-n], also den 
Wert, der vor n Schritten am Ausgang lag.
x^(n-1) bedeutet demzufolge y[k-n+1].
x^1 bedeutet demzufolge y[k-1]
1 bedeutet demzufolge y[k] - die gesuchte Größe.
Genauso bedeutet auf der Rechten Seite x^n soviel wie u[k-n].
Links stehen also die Ausgangswerte, rechts die Eingangswerte
- nun einfach nur noch die vergangenen Ausgangswerte mit "minus" nach 
rechts bringen und schon habt die Berechnungsvorschrift für eine 
Ableitungsnäherung beliebiger Genauigkeit.

Beispiel n=4 - hoffe mal, ich hab mich nicht verrechnet:

int u_k1 = 0;
int u_k2 = 0; // nur Zwischenspeicher, kommt in Formel nicht vor.
int u_k3 = 0;
int u_k4 = 0;
int y_k1 = 0;
int y_k2 = 0;
int y_k3 = 0;
int y_k4 = 0;
do
{
  y = (int)(5.0/6.0*(5*u + 32*u_k1 - 32*u_k3 - 5*u_k4) - 16*y_k1 - 16*y_k2 - 16*y_k3 - y_k4);
  u_k4 = u_k3;
  u_k3 = u_k2;
  u_k2 = u_k1;
  u_k1 = u;
  y_k4 = y_k3;
  y_k3 = y_k2;
  y_k2 = y_k1;
  y_k1 = y;
}

Weiterführendes
Aus einer Beliebigen Übertragungsfunktion G(s) lässt sich G(x) gewinnen, 
indem man einfach jedes auftretende s durch die gewählte 
Padé-Approximation ersetzt. Das Umformen und Auflösen könnte hier 
allerdings Arbeit bedeuten. Evtl eine Mathetool verwenden?

ToDo
- Ermitteln, bis zu welcher Ordnung sich der Genauigkeitsgewinn lohnt, 
da er ja Rechenzeit kostet, und damit T wächst. Im schlimmsten Fall 
bleibt die Realisierung in PLD als Ausweg. Dann steigt nämlich "nur" die 
Komplexität und nicht T. Außerdem liegt irgendwann der 
Genauigkeitsgewinn außerhalb der Wahrnehmbarkeit, wenn man nicht den 
Variablentyp ändert.
- Testen der Vorgehensweise in der Praxis = Fehlersuche... :/