Differentiation und Integration

Infinitesimalrechnung (Calculus)

Differenzieren "derive"¹

Die Funktion derive() leitet das Eingangssignal $x(t)$ nach der Zeit ab.

$$y = \frac{d}{dt}x(t), \quad [y] = \frac{[x]}{\mathrm{s}}$$

Ohne JSON-Konfiguration berechnet derive() den instantanen Quotienten $\Delta x / \Delta t$ zwischen je zwei aufeinanderfolgenden Evaluierungszeitpunkten. Dieser einfache Modus ist nur dann sinnvoll, wenn das Eingangssignal tatsächlich linear interpolierbar ist, zum Beispiel äquidistant abgetastete Messwerte mit #interpolateLin.

Für äquidistante Signalverläufe wird der Gittermodus empfohlen: Mit fOut wird das Eingangssignal auf ein gleichmäßiges Zeitgitter umgesampelt und mit einem gleitenden FIR-Differenzierfilter der Ordnung nFilt abgeleitet. Das FIR-Filter bildet einen gewichteten Differenzenquotienten über die letzten $2 \cdot \texttt{nFilt}$ Gitterpunkte und ermöglicht damit einen Kompromiss zwischen Rauschunterdrückung und Phasenverzögerung.

Für Signale mit zyklischem Wertebereich (z. B. Winkelzähler 0°..360° oder Inkrementalgeber mit Überlauf) aktiviert der Parameter modulo eine Überlaufkorrektur. Die Funktion erkennt Überläufe anhand der Überlaufzone ovflz und korrigiert den Gradienten so, dass kein Vorzeichensprung im Ableitungsergebnis auftritt.

y1 = derive(x);
y2 = derive(x, { fOut:      <dbl>|'def'
               , nFilt:     <uint>
               , reduction: <uint>
               , modulo:    <dbl>
               , ovflz:     <dbl>
               });

Eigenschaft	Wert	Beschreibung
fOut	def/<dbl>	Ausgabe-Abtastfrequenz des Gittermodus in Hz. 'def' verwendet die globale Abtastzeit (discreteSampleTimeMs). Minimalwert: 0,1 Hz.
nFilt	<uint>	Filterordnung des gleitenden FIR-Differenzierfilters. Höhere Werte reduzieren Rauschen auf Kosten der Phasenverzögerung. Nur im Gittermodus wirksam. Default: 2, Wertebereich: $[2 \ldots 10]$
reduction	<uint>	Gibt nur jeden n-ten berechneten Gitterpunkt aus. Ermöglicht eine Ausgangsrate unterhalb von fOut. Werte ≤ 1 werden ignoriert.
modulo	<dbl>	Aktiviert die Überlaufkorrektur für zyklische Signale. Gibt den vollen Wertebereich an (z. B. 360.0 für Winkel in Grad, 6.2832 für Winkel in Radiant). Wertebereich: $> 0.0$
ovflz	<dbl>	Überlaufzone als Anteil von modulo. Ein Überlauf wird erkannt, wenn der neue Wert die Zone $[0,\ \mathtt{ovflz} \cdot \mathtt{modulo}[$ und der vorherige die Zone $](1-\mathtt{ovflz}) \cdot \mathtt{modulo},\ \mathtt{modulo}]$ belegt (oder umgekehrt). Default: 0,333, Wertebereich: $]0,0; 0,5[$

hinweis

Da der smartCORE in der Regel nicht äquidistante Signalwerte nur in einen Kanal schreibt, wenn sich der Wert geändert hat, ist der Wert zwischen zwei expliziten Stützpunkten immer als Konstant anzunehmen und es fehlt die Information für das letzte, reale Abtastintervall. Zwischen den Stützstellen gilt immer der linksseitige Signalwert (Halteglied 0ter Ordnung). Es ergibt sich ein treppenförmiger Signalverlauf.

Die Anwendung der Differentiation auf nicht äquidistante Signale mit treppenförmigem Verlauf ist sinnfrei. Das Ergebnis wäre entweder $0$ oder $\pm \infty$

Integrieren "integrate"

Die Funktion integrate() liefert das Zeitintegral über der Eingangsfunktion x

$$y = \int_0^tx(\tau)d\tau$$

Da $x(\tau)$ immer zu nicht äquidistanten Zeitpunkten $t_0, t_1, t_2, ... t_n$ einzelne Stützstellen liefert, zwischen denen jeweils der linksseitige Funktionswert als konstant angenommen wird, lässt sich das Integral auch als Summe schreiben:

$$y = \sum_{n=0}^{N-1}x(t_n)(t_{n+1}-t_n)$$

Die physikalische Einheit des Ergebnisses ist um eine Zeitdimension erweitert: $[y] = [x] \cdot \rm{s}$.

hinweis

Für äquidistante Signale ist zukünftige eine Trapez-Integration vorgesehen.

I1 = integrate(y);
I2 = integrate(y, reset);
I3 = integrate(y, reset, preset);
// Optionale Konfiguration für alle Varianten
Ix = integrate(..., { start: <dbl>
                    , preset: <dbl>
                    , lower: off|<dbl>
                    , upper: off|<dbl>
                    , storage: <str> 
                    });

Falls über den optionalen Parameter reset ein true geliefert wird, wird das Integral auf den mit preset (als Parameter oder Eigenschaft, default 0.0) fest gelegten Wert zurückgestellt und gehalten. Unmittelbar vor der Rückstellung wird ein weiteres Sample eingefügt, mit dem der letzte bis dahin angefallene Integralwert ausgegeben wird ("true peak").

Eigenschaft	Wert	Beschreibung
start	<dbl>	Erster Startwert für das Integral beim Starten des Math Moduls
preset	<dbl>	Fester Wert für die Rückstellung des Integrals über den reset Parameter
lower	off/<dbl>	Begrenzt den Integralwert nach unten, falls aktiviert. Dies wird z.B. für die Implementierung von Reglerstrukturen oder Modellen benötigt, bei denen der Integrationsvorgang durch eine physikalische Grenze limitiert ist.
upper	off/<dbl>	Begrenzt den Integralwert nach oben, falls aktiviert. Dies wird z.B. für die Implementierung von Reglerstrukturen oder Modellen benötigt, bei denen der Integrationsvorgang durch eine physikalische Grenze limitiert ist.
storage	<str>	Name eines persistenten Speichers für den internen Integralwert. Damit wird nach einem Neustart des Systems die Integration am letzten gespeicherten Wert fortgesetzt. Der Inhalt dieses Speichers ist  an keiner anderen Stelle im smartCORE nutzbar.

Beispiel:

Im Beispiel 1a wird die Funktion integrate() zur Berechnung der elektrischen Energie aus Strom- und Spannungszeitverläufen verwendet.

Im Beispiel 10 wird die Funktion integrate() zur Messung von Zeiten verwendet.

Summieren "sumup"

Die Funktion sumup() liefert die Summe über Einzelwerte des Eingangssignals x zu den Zeiten einer positiven Flanke auf dem trigger Parameter

$$y = \sum_{n=0}^{N-1}x(t_n)\quad\rm{mit}\quad t_n=time(posedge(trigger))$$

S1 = sumup(x, trigger);
S2 = sumup(x, trigger, reset);
// Optionale Konfiguration für alle Varianten
Sx = sumup(... , { storage: <str>
                 });

Falls über den optionalen Parameter reset ein true geliefert wird, wird die Summe 0.0 zurückgestellt und gehalten.

Eigenschaft	Wert	Beschreibung
storage	<str>	Name eines persistenten Speichers für den internen Summenwert. Damit wird nach einem Neustart des Systems die Summe am letzten gespeicherten Wert fortgesetzt. Der Inhalt dieses Speichers ist  an keiner anderen Stelle im smartCORE nutzbar.

Footnotes

1. Ab Katalog Version 13 verfügbar. ↩