Différentiation et intégration

Calcul infinitésimal (Calculus)

Dérivation « derive »¹

La fonction derive() dérive le signal d'entrée $x(t)$ par rapport au temps.

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

Sans configuration JSON, derive() calcule le quotient instantané $\Delta x / \Delta t$ entre deux instants d'évaluation consécutifs. Ce mode simple n'a de sens que si le signal d'entrée est effectivement interpolable de manière linéaire, par exemple des valeurs mesurées échantillonnées de manière équidistante avec #interpolateLin.

Pour les signaux équidistants, le mode grille est recommandé : avec fOut, le signal d'entrée est rééchantillonné sur une grille temporelle régulière et dérivé avec un filtre différentiateur FIR glissant d'ordre nFilt. Le filtre FIR forme un quotient différentiel pondéré sur les $2 \cdot \texttt{nFilt}$ derniers points de la grille et permet ainsi un compromis entre suppression du bruit et retard de phase.

Pour les signaux à plage de valeurs cyclique (par ex. compteur d'angle 0°..360° ou codeur incrémental avec débordement), le paramètre modulo active une correction de débordement. La fonction détecte les débordements à l'aide de la zone de débordement ovflz et corrige le gradient de manière qu'aucun saut de signe n'apparaisse dans le résultat de la dérivation.

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

Propriété	Valeur	Description
fOut	`def/<dbl>`	Fréquence d'échantillonnage de sortie du mode grille en Hz. `'def'` utilise le temps d'échantillonnage global (discreteSampleTimeMs). Valeur minimale : 0,1 Hz.
nFilt	`<uint>`	Ordre du filtre différentiateur FIR glissant. Des valeurs plus élevées réduisent le bruit au détriment du retard de phase. Effectif uniquement en mode grille. Par défaut : 2, plage de valeurs : $[2 \ldots 10]$
reduction	`<uint>`	Ne fournit qu'un point de grille calculé sur n. Permet un taux de sortie inférieur à `fOut`. Les valeurs ≤ 1 sont ignorées.
modulo	`<dbl>`	Active la correction de débordement pour les signaux cycliques. Indique la plage de valeurs complète (par ex. `360.0` pour des angles en degrés, `6.2832` pour des angles en radians). Plage de valeurs : $> 0.0$
ovflz	`<dbl>`	Zone de débordement en proportion de `modulo`. Un débordement est détecté lorsque la nouvelle valeur occupe la zone $[0,\ \mathtt{ovflz} \cdot \mathtt{modulo}[$ et la valeur précédente la zone $](1-\mathtt{ovflz}) \cdot \mathtt{modulo},\ \mathtt{modulo}]$ (ou inversement). Par défaut : 0,333, plage de valeurs : $]0,0; 0,5[$

remarque

Comme le smartCORE n'écrit en règle générale les valeurs de signaux non équidistants dans un canal que lorsque la valeur a changé, la valeur entre deux points d'appui explicites doit toujours être supposée constante, et l'information sur le dernier intervalle d'échantillonnage réel fait défaut. Entre les points d'appui, c'est toujours la valeur du signal à gauche qui s'applique (bloqueur d'ordre zéro). Il en résulte une allure de signal en escalier.

Appliquer la dérivation à des signaux non équidistants à allure en escalier n'a aucun sens. Le résultat serait soit $0$ , soit $\pm \infty$

Intégration « integrate »

La fonction integrate() fournit l'intégrale temporelle de la fonction d'entrée x

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

Comme $x(\tau)$ fournit toujours des points d'appui isolés à des instants non équidistants $t_0, t_1, t_2, ... t_n$ , entre lesquels la valeur de la fonction à gauche est supposée constante, l'intégrale peut aussi s'écrire sous forme de somme :

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

L'unité physique du résultat est étendue d'une dimension temps : $[y] = [x] \cdot \rm{s}$ .

remarque

Pour les signaux équidistants, une intégration par la méthode des trapèzes est prévue à l'avenir.

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> 
                    });

Si le paramètre facultatif reset fournit true, l'intégrale est remise à la valeur définie par preset (comme paramètre ou propriété, par défaut 0.0) et maintenue. Immédiatement avant la remise à zéro, un échantillon supplémentaire est inséré, avec lequel la dernière valeur d'intégrale accumulée jusque-là est fournie (« true peak »).

Propriété	Valeur	Description
start	`<dbl>`	Première valeur de départ de l'intégrale au démarrage du module Math
preset	`<dbl>`	Valeur fixe pour la remise à zéro de l'intégrale via le paramètre reset
lower	`off/<dbl>`	Limite l'intégrale vers le bas, si activé. Cela est nécessaire par ex. pour l'implémentation de structures de régulation ou de modèles dans lesquels le processus d'intégration est limité par une borne physique.
upper	`off/<dbl>`	Limite l'intégrale vers le haut, si activé. Cela est nécessaire par ex. pour l'implémentation de structures de régulation ou de modèles dans lesquels le processus d'intégration est limité par une borne physique.
storage	`<str>`	Nom d'une mémoire persistante pour la valeur interne de l'intégrale. Après un redémarrage du système, l'intégration reprend ainsi à la dernière valeur enregistrée. Le contenu de cette mémoire n'est utilisable nulle part ailleurs dans le smartCORE.

Exemple :

Dans l'exemple 1a, la fonction integrate() est utilisée pour calculer l'énergie électrique à partir des évolutions temporelles du courant et de la tension.

Dans l'exemple 10, la fonction integrate() est utilisée pour mesurer des durées.

Sommation « sumup »

La fonction sumup() fournit la somme des valeurs individuelles du signal d'entrée x aux instants d'un front montant sur le paramètre trigger

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>
                 });

Si le paramètre facultatif reset fournit true, la somme est remise à 0.0 et maintenue.

Propriété	Valeur	Description
storage	`<str>`	Nom d'une mémoire persistante pour la valeur interne de la somme. Après un redémarrage du système, la somme reprend ainsi à la dernière valeur enregistrée. Le contenu de cette mémoire n'est utilisable nulle part ailleurs dans le smartCORE.

Disponible à partir de la version de catalogue 13. ↩

Calcul infinitésimal (Calculus)​

Dérivation « derive »1​

Intégration « integrate »​

Exemple :​

Sommation « sumup »​

Footnotes​

Calcul infinitésimal (Calculus)

Dérivation « derive »¹

Intégration « integrate »

Exemple :

Sommation « sumup »

Footnotes