Module de calcul « math »

---

INFORMATIONS PRÉALABLES IMPORTANTES

important

Ce module est fourni sans aucune garantie expresse ou implicite, y compris, entre autres, la garantie implicite d'aptitude du module à un usage particulier.

En aucun cas optiMEAS GmbH ou les contributeurs de ce module ne sauraient être tenus responsables de dommages directs, indirects, accessoires, spéciaux, exemplaires ou consécutifs (notamment l'acquisition de biens ou de services de remplacement, la limitation et/ou la perte de la capacité d'utilisation, de données, de bénéfices ou l'interruption d'activité), quelle qu'en soit la cause et quel que soit le fondement de la responsabilité, qu'il s'agisse de contrat, de responsabilité stricte ou de délit (y compris la négligence), survenus de quelque manière que ce soit du fait de l'utilisation de ce module, même s'ils ont été avertis de la possibilité de tels dommages.

remarque

Il faut partir du principe que la fonctionnalité relative au catalogue de fonctions, aux interfaces, au paramétrage ou à des éléments similaires est incomplète et peut être fournie sous une forme modifiée dans les versions futures. L'exploitation s'effectue donc sous votre propre responsabilité.

astuce

Nous sommes extrêmement reconnaissants pour toutes les suggestions d'amélioration et tous les conseils issus de l'utilisation de ce module, et encourageons les utilisateurs à nous contacter à ce sujet.

---

Description

Le module de calcul « math » permet d'appliquer à différentes données un jeu de formules défini par l'utilisateur, faisant appel à des fonctions variées.

Les données (arguments, expressions) comprennent, d'une part, les données de canaux smartCORE en général variables dans le temps, auxquelles on peut accéder par les noms de canaux, et, d'autre part, des expressions constantes, des ressources, des données persistantes ainsi que des données fournies ou préparées à l'aide de décodeurs.

Outre les données unidimensionnelles, les données multidimensionnelles sous forme de vecteurs et de matrices sont également prises en charge, tous les composants de ces données pouvant reposer sur des types de données différents, et une conversion de type automatique étant effectuée si nécessaire.

La description de l'étendue du langage peut être consultée sous

Référence du langage

Les fonctions prises en charge comprennent notamment

• les opérateurs arithmétiques et logiques, y compris leur priorité et leur associativité
• les fonctions mathématiques et trigonométriques
• les fonctions de filtrage temporel (comme par exemple la différentiation et l'intégration de fonctions)
• les algorithmes numériques (par ex. FFT, décomposition de matrices, interpolation, prédiction)
• l'échantillonnage (sampling) de données de mesure
• les fonctions de comptage et les timers
• les fonctions de sélection, les fonctions orientées bit ainsi que les fonctions de conversion de type (type casts)
• le séquencement d'expressions et d'affectations
• les fonctions opérant sur des chaînes de caractères

Référence des fonctions

Exemples

D'une manière générale, il est judicieux, dans le cadre de la configuration, d'examiner un exemple minimal et de l'adapter à ses besoins.

Un exemple minimal, qui calcule les canaux de sortie Leistung et Energie à partir de deux canaux d'entrée smartCORE fictifs Spannung et Strom à l'aide des équations aux grandeurs physiques

$$P = U \cdot I \cdot \frac{[\rm{A}]}{[\rm{mA}]}$$ $$W = \frac{[\rm{kWh}]}{[\rm{Ws}]} \cdot \int_{0}^{t} P(\tau) d\tau$$

est présenté ci-après

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": [
      "Leistung = Spannung * Strom * 1e-3;              //  Strom in mA!",
      "Energie = 1/(3600 * 1e3) * integrate(Leistung);  //  Energie in kWh!"
    ],
    "outputs": [
      {
        "datatype": "double",
        "name": "Leistung",
        "physicalUnit": "W"
      },
      {
        "datatype": "double",
        "name": "Energie",
        "physicalUnit": "kWh"
      }
    ]
  }
}

Pour les calculs dont la complexité d'exécution dépasse les exigences temps réel, l'utilisation d'une Lookup Table (LUT) est recommandée. Dans l'exemple suivant, le volume de carburant dans un réservoir est déterminé par interpolation dans la Lookup Table à partir de la pression régnant au fond de ce réservoir, le contenu de cette LUT étant fourni via resources à partir d'un fichier présent dans le système de fichiers

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": [
      "Volumen = lookup(Druck, {$ref:'Tank_LUT'});"
    ],
    "outputs": [
      {
        "datatype": "double",
        "name": "Volumen",
        "physicalUnit": "l"
      }
    ],
    "resources": {
      "Tank_LUT": {
        "decoder": [
          "file"
        ],
        "value": "Tank_LUT.lut"
      }
    }
  }
}

Le contenu du fichier Tank_LUT.lut serait alors le suivant, conformément à la description de la fonction lookup() (toutes les 161 valeurs d'appui n'étant pas listées ici) :

IN    kPa    0.0    0.167751    161
OUT    l

0
42.942
87.924
134.946
184.008
235.11
288.252
343.434
400.656
459.918
521.22
584.562
649.944
... usw

Motivation

L'utilisation du module de calcul mathmodule permet notamment ce qui suit

• Diagnostic et analyse d'états de processus directement sur l'appareil
• Réduction du volume de données à transmettre en se concentrant sur des valeurs caractéristiques ou des tendances
• Mesures virtuelles sur des signaux de mesure, par ex. durée d'un mouvement de porte, amplitude d'un signal, etc.
• Compteurs d'événements, compteurs d'heures de fonctionnement, intégrales
• Classifications (durée de séjour, franchissements, rainflow, ...)
• Combinaison de grandeurs de mesure à plusieurs composantes (rosettes de jauges de contrainte)
• Implémentation rapide de PoC pour le (pré)développement de plug-ins
• Fonctions de commande simples

Configuration JSON

Une configuration minimale requise du module de calcul a essentiellement la structure suivante

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": [

      < MATH >

    ],
    "outputs": [

      < OUTPUTS >

    ]
  }
}

Une configuration complète du module de calcul a en revanche essentiellement la structure suivante

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "packages": [
      "some function package",
      "another function package",
      ...
    ],
    "evaluationTimeMs": 1000,
    "inputTimeoutS": 15,
    "discreteSampleTimeMs": 100,
    "math": [

      < MATH >

    ],
    "outputs": [

      < OUTPUTS >

    ],
    "resources": {
      "someTextResource": [

          < LINES OF TEXT >

      ],
      "someObjectResource": {

          < JSON STYLE Config >

      },
      "someDecodableResource": {
        "decoder": [

          < DECODERS >

        ],
        "value": "someInitialStringValue"
      },
      ...
    }
  }
}

Paramètres globaux du module

Les paramètres suivants peuvent être utilisés dans le cadre de la configuration du module

Nom du paramètre	Requis	Type de données	Plage de valeurs raisonnable	Valeur par défaut	Description
packages	Non	JSON Array of STRING		EMPTY JSON Array	Liste contenant des packages de fonctions facultatifs
evaluationTimeMs	Non	INT	100 -	1000 (1 s)	Intervalle d'appel du calcul (polling interval) en ms
inputTimeoutS	Non	INT	10 -	15 (15 s)	Timeout après lequel on n'attend plus de données de canal et où le calcul se poursuit avec la dernière valeur du canal, en s
discreteSampleTimeMs	Non	INT	1 -	100 (100 ms)	Temps d'échantillonnage (pas de la grille temporelle sous-jacente) pour le calcul/l'évaluation à temps discret de parties de formules récursives, en ms
math	OUI	JSON Array of STRING resp. STRING			Chaîne, resp. liste de chaînes concaténées en une seule chaîne, représentant le jeu de formules du calcul (voir ci-dessous)
outputs	OUI	JSON Array of JSON Object for Channel Configuration			Liste de tous les canaux de sortie et, au-delà, de tous les canaux d'entrée persistants (voir ci-dessous)
resources	Non	JSON Object for Resource Configuration			Objet qui configure les ressources utilisées (voir ci-dessous)
minLogLevel	Non	ENUM	OFF, DEBUG, INFO, WARNING, ERROR, FATAL	INFO	Filtre de sortie pour les messages du module Math ; seuls les messages d'une gravité au moins égale à celle indiquée sont écrits dans le fichier journal.

Configuration du jeu de formules « math »

Selon sa complexité, le jeu de formules du calcul à exécuter périodiquement peut être spécifié soit sous forme d'une seule chaîne, soit sous forme d'une liste de chaînes (sous la forme d'un tableau JSON). Si une liste est spécifiée, tous les éléments de la liste sont mis bout à bout comme lignes du jeu de formules, avec le caractère de liaison \n.

Des informations complémentaires sont disponibles sur les pages suivantes :

• Description de la fonction générale
• Sémantique et syntaxe, opérateurs
• Référence des fonctions
• Utilisation des ressources
• ainsi que divers exemples d'application

Des exemples de jeux de formules figurent ci-après

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": "y = 42;"
  }
}

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": [
      "c = 42;",
      "y = c;"
    ]
  }
}

important

Dans cette documentation, l'accent est mis sur le jeu de formules multiligne proprement dit. Lors du transfert du jeu de formules dans la configuration JSON, les différentes lignes du jeu de formules doivent donc être encadrées par " ... ". Cela implique que tous les caractères d'échappement " et \ du texte de la formule doivent à nouveau être neutralisés pour l'analyseur JSON au moyen du caractère d'échappement \.

Ce formatage supplémentaire n'est pas pris en compte dans les exemples de cette référence des fonctions, car il est en général appliqué automatiquement par l'éditeur utilisé, par ex. dans optiCONTROL.

À partir du texte de formule suivant, comportant divers éléments de texte, et d'une configuration

s1a = '17" (inch)';
s1b = "17\" (inch)";
s2a = "Hat's funktioniert?\t[ja/nein]";
s2b = 'Hat\'s funktioniert?\t[ja/nein]';
fnc = myParameterFunction(x, {"property":"value"});

on obtient dans la configuration JSON du module Math

    "math": [
      "s1a = '17\" (inch)';",
      "s1b = \"17\\\" (inch)\";",
      "s2a = \"Hat's funktioniert?\\t[ja/nein]\";",
      "s2b= 'Hat\\'s funktioniert?\\t[ja/nein]';",
      "fnc = myParameterFunction(x, {\"property\":\"value\"});"
    ], ...

Configuration des canaux de sortie « outputs »

D'une manière générale, le module de calcul sert à calculer des valeurs de sortie qui sont produites dans des canaux smartCORE.

Pour ces canaux, il doit exister dans le jeu de formules exactement une affectation chacun, et ils doivent être configurés sous « outputs » selon les standards smartCORE courants.

Les affectations qui ne sont pas publiées dans la section « outputs » sont considérées comme des variables internes et locales du jeu de formules.

L'exemple minimal suivant exporte par conséquent le canal speed

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": [
      "c = 42;",
      "speed = c;"
    ],
    "outputs": [
      {
        "dataType": "double",
        "name": "speed",
        "physicalUnit": "m/s"
      }
    ]
  }
}

Une configuration un peu plus flexible, décrivant en outre des caractéristiques de canal supplémentaires ainsi qu'une chaîne de filtres de production à un étage, se présenterait comme suit

{
  "module":"math1",
  "factory":"mathmodule",
  "config": {
    "math": [
      "c = 42;",
      "speed = c;"
    ],
    "outputs": [
      {
        "dataType": "double",
        "name": "speed",
        "physicalUnit": "m/s",
        "bufferSize": 1024,
        "channelType": "timestamped",
        "filter": [
          {
            "name": "datareduction",
            "absTolerance": 0.0,
            "timeoutMs": 60000
          }
        ]
      }
    ]
  }
}

Configuration des ressources « resources »

La mise à disposition de ressources est un élément important du module Math pour réaliser également des configurations et des fonctionnalités complexes. La description correspondante se trouve ici.