Lisser ou Filtrer avec la box eedomus les données d'un ou plusieurs capteur (Température, pH, puissance, ...).
Ce plugin, créé pour la box eedomus, permet de filtrer un signal avec divers filtres, en particulier moyenne, exponentiel, FIR (filtre à Réponse Impulsionnelle Finie) ou IIR (filtre à Réponse Impulsionnelle Infinie) ou des filtres classiques : Butterworth, Tchebychev, fenêtre de Hann, Hamming....
Il permet d'appliquer un prétraitement des données pour modifier le gain, l'offset ou limiter (ou supprimer) des valeurs d'entrée hors limites ou une impulsion (valeur aberrante sur une mesure) en les prétraitant avant de les envoyer dans le filtre de traitement numérique.
La version V1.2 permet de combiner plusieurs capteurs avant d'appliquer le prétraitement et le traitement.
Le système effectue un suréchantillonnage toutes les minutes pour obtenir des données périodiques.
qui a développé ?
Version actuelle de ce document : V1.2.1 (version V1.2 du script 2024/07/08)
Le PLUGIN se trouve dans le store eedomus. Pour l'installer, il faut cliquer dessus, puis sur créer. Dans la nouvelle page ouverte, adapter le nom, choisissez la pièce, éventuellement saisir une remarque.
Il faudra renseigner
3 listes de paramètres : Les paramètres de contrôle (L0), les coefficients directs (L1) et les coefficients inverses (L2) qui seront copiés dans [VAR2] à la suite du numéro de la méthode. Les listes vides comportent un 0.
Pour les autres filtres utilisables, on choisira la méthode autre (filtre 9) et on mettra le nom du filtre (ou son numéro) en paramètre_1 :
Si on laisse, les paramètres par défaut, ils seront adaptés et pourront être modifiés par la suite dans la fenêtre du PLUGIN.
Les options de type de prétraitement qui seront copiées dans [VAR3], par exemple [VAR3] mul:1.8,add:32 (conversion Celsius -> Farenheit)
Le PLUGIN est de type capteur HTTP.
L'URL de la requête est : http://localhost/script/?exec=filtrage.php&periph_id=[VAR1]&methode=[VAR2]¶metre=[VAR3]
Le Chemin XPATH /root/Value ou //Value
La Fréquence de la Requête est : 1 (1 minute)
Les champs [VAR1] (periph_id), [VAR2] (methode) [VAR3] (parametre) contiennent les valeurs à transmettre. ( voir § 5.6)
Pour modifier les caractéristiques id_capteur, filtre et préfiltre, il faudra ouvrir la fenêtre du PLUGIN et modifier les valeurs des variables [VAR1], [VAR2] et [VAR3]. Si on veut effectuer des comparaisons pour divers réglages des paramètres, on pourra dupliquer le PLUGIN, modifier la copie et comparer les effets des divers réglages pour un même capteur.
Pour s'assurer du bon fonctionnement, depuis la fenêtre du PLUGIN, on peut passer en mode test (appuyer sur *Tester*) et éventuellement passer en mode *debug* en ajoutant en bout de chaîne de commande (dans *Utiliser l'URL*) la commande &debug=1, puis en cliquant sur *Tester*. Le resultat du XPATH reste valable, même en mode debug. Pour vérifier que le traitement conduit bien à une valeur stable, on peut imposer un nombre *nb* de valeurs identiques successives en ajoutant la commande &reset=nb (ou éventuellement &reset=-nb, s'il y a un prétraitement); *nb* doit être suffisamment grand pour saturer les mémoires de traitement : égal au nombre de coefficients pour un filtre FIR et environ 5 fois l'ordre du filtre pour un filtre IIR. Par défaut, le PLUGIN effectue une saturation des mémoires à chaque modification des paramètres.
Chaque PLUGIN sauvegarde ses données en mémoire permanente, on risque donc de créer de nombreuses variables si on teste plusieurs PLUGIN. Avant de supprimer un PLUGIN, il est donc recommandé de passer en mode test et de lancer la commande *delete* : ajouter en fin de ligne de commande &delete=1 ; on pourra ensuite effacer le PLUGIN. Une solution plus radicale consiste à supprimer le fichier *filtrage.php* de la liste des scripts (lancer http://eedomus.local/script/) et à le recharger à nouveau : toutes les variables de tous les PLUGIN liés à *filtrage.php* seront supprimées.
Capteur de température Oregon 433MHz : Les capteurs renvoient parfois des valeurs fausses (0 ou valeur avec un chiffre manquant : 1.7 au lieu de 14.7) qui sont corrigées à la lecture suivante (environ 1 minute plus tard), ce qui écrase les graphiques de l'eedomus qui ajuste automatiquement le gain. Le préfiltre dmax ou médian permet d'éliminer cet artefact. On peut donc utiliser un préfiltre [VAR3] -> dmax:val ou med et mettre dans [VAR2] nul ou éventuellement un Butterworth pour lisser sur une plus grande période.
Les données provenant d'un ou plusieurs capteur renvoyant une valeur numérique peuvent être combinées puis prétraitées et filtrées en utilisant diverses méthodes de filtrage numérique.
Si le script doit calculer les coefficients finaux à partir de données générales (type de filtre,...); il les calcule seulement à le première utilisation, ou lors d'un changement de paramètres, puis les stocke en mémoire.
S'il y a un préfiltrage de type moy ou med, les valeurs renvoyées restent inchangées tant que le préfiltre n'a pas fini son calcul : avec moy:5, (5 renvois identiques toutes les minutes pendant 5 minutes).
Le filtrage des données est d'autant plus efficace que le degré du filtre est élevé, mais celà introduit un retard du signal de sortie d'autant plus fort que le degré du filtre est important. On ne peut pas filtrer de manière forte un signal d'alarme qui doit faire réagir rapidement!!
Les données de plusieurs capteurs peuvent être adaptées (combinaison) (gain, offset,...) avant d'être prétraitées.
Les diverses données utilisées correspondent à la valeur du signal à des instants réguliers, espacés de Te (période d'échantillonnage de l'ordre de la minute pour l'eedomus), E = {X(n),X(n-1),X(n-2)...X(0)} (X(n) est la plus récente). Ces données sont multipliées par les coefficients (Coeffsdir) B {B(0),B(1),B(2),...,B(M)} et additionnées pour obtenir Sdir.
Les sorties S = {Y(n),Y(n-1),Y(n-2)...,Y(0)} (Y(n) : valeur à calculer) correspondant aux valeurs calculées après chaque lecture sont sauvegardées, puis les dernières valeurs (de n-1 à 0) sont multipliées par les coefficients (Coeffsrev) A {A(0),A(1),A(2),...,A(N)} et additionnées pour obtenir : Y(n)*A(0) = Sdir - Srev ou Y = (Sdir - Srev)/A(0)```.
Les filtres numériques peuvent être équivalent aux filtres analogiques utilisés en électronique ou pas. Si tous les coefficients A(i) sont nuls sauf A(0), souvent égal à 1, le filtre résultant est un filtre à réponse impulsionnelle finie (F**inite **I***mpulse* **R***esponse* (FIR) filter); si les coefficients A(i) comportent au moins 2 valeurs non nulles (A(0) et A(i)) le filtre résultant est un filtre à réponse impulsionnelle infinie (Ifinite **I***mpulse* **R***esponse* (IIR**) filter). La réponse impulsionnelle correspond à la réponse du système (filtre) à une impulsion unitaire (entrées nulles sauf X(0)=1; X(i!=0)=0 et X(0)=1).
On peut utiliser des filtres quelconques en déclarant la liste des coefficients de B et A (liste séparées par des ";", éléments de la liste séparés par des ","). Tous les éléments doivent être présents : N+1 valeurs pour A et M+1 valeurs pour B.
Il existe 4 types de filtres, les filtres passe-bas (low pass) qui éliminent les variations rapides (bruit), les filtres passe-haut (high pass) qui éliminent les variations lentes (dérive), les filtres passe-bande (bandpass) qui conservent les fréquences intermédiaires et les filtres coupe-bande ou réjecteurs (notch filter) qui éliminent les fréquences intermédiaires. Ces filtres sont en général caractérisés par leurs valeurs de coupure et d'atténuation et la forme de leur réponse. Pour un passe-bas, l'amplitude du signal est très peu changée si la fréquence est inférieure à la fréquence de coupure et très atténuée si la fréquence est supérieure à la fréquence d'atténuation. Pour un type de filtre donné, on peut définir son ordre (degré max des polynômes); plus l'ordre est élevé, plus le filtre est raide et plus le filtre sera long à réagir et lourd en calculs.
On s'intéresse généralement à la réponse du filtre en fonction des fréquences présentes dans le signal, en particulier à la réponse impulsionnelle et à la réponse indicielle (résultat à une entrée valant 0 jusqu'à un instant donné et 1 ensuite : signal en marche d'escalier). Pour un filtre passe-bas, la réponse indicielle montera plus ou moins rapidement de 0 vers 1, en oscillant éventuellement autour de 1, pour se stabiliser vers 1 (si le filtre est stable).
Les filtres les plus simples à réaliser sont la moyenne (B(i)=1 pour 0<=i<=M; A(0)=M+1) ou la moyenne pondérée (B(i)=b(i) pour 0<=i<=M; A(0)=M+1) : si tous les coefficients b(i) sont de même signe, ce sont des filtres passe bas FIR qui permettent un lissage, ils sont stables mais nécessitent plus de coefficients que les filtres IIR.
Le filtre IIR le plus simple est le filtre exponentiel qui oublie progressivement les valeurs les plus anciennes (B(0) = 1/N; A(0) = 1, A(1)=-(1-1/N) donc Y(1) = (X + (N-1)*Y(0))/N. N représente le nombre d'échantillons de temps (t = N*Te) au bout duquel la réponse indicielle atteint environ 70% du plateau : c'est à peu près le nombre d'échantillons que l'on veut atténuer.
Tous les filtres numériques sont utilisables dans le script à condition de connaître les coefficients : un filtre IIR quelconque peut être instable. Les coefficients peuvent être récupérés sur internet, en les adaptant aux fréquences concernées, ou avec des applications qui tiennent compte de cette adaptation. Un certain nombre de filtres ont été préprogrammés dans le script pour déterminer les coefficients adaptés :
Le prétraitement optionnel permet de modifier la donnée d'entrée il doit rester simple pour être efficace. Les valeurs sont échantillonnées régulièrement, toutes les minutes par défaut, même si le capteur n'a rien renvoyé. Les opérations sont du type op:val et peuvent être enchaînées op1:val1,op2:val2,op3:val3 pour être réalisées dans l'ordre, sauf moy et med qui sont effectuées à la fin (on peut remplacer les "," par des ";"). Les valeurs val sont numériques ou peuvent prendre la valeur pi ou npim (n et m nombres, ->n*pi/m) : 3pi2 -> 3*pi/2 = 4,712388980... Si val est omis, il sera mis à 0.
Les opérations autorisées sont :
Opérations directes :
Opérations utilisant les valeurs antérieures :
Dans certains cas, les préfiltres moy ou med suffisent pour améliorer le signal et le filtrage suivant n'est pas nécessaire : on pourra alors utiliser le filtre nul.
Si on remplace le capteur unique par des listes de capteurs séparés par un ";", les valeurs de chaque capteur seront additionnées avant d'être injectées dans le préfiltre.
On peut aussi adapter les valeurs d'un capteur avant de les combiner, en utilisant une ou plusieurs des opérations directes autorisées lors du prétraitement id_capteur,sub:32,div:1.8 (pour transformer un capteur Farenheit en capteur Celsius) ou id_capteur,div:1000 (pour transformer un capteur Wh en capteur kWh).
Le script crée un pseudo-capteur d'id 0 et ulilise les listes *0;id_capteur1;id_capteur2;...*.
Pour des capteurs contenant les valeurs x, y, z, le résultat est *x+y+z* ou *f(x)+g(y)+h(z)* si les données initiales sont adaptées. Les valeurs des opérations directes peuvent être fixes ou dépendre d'un capteur désigné par son numéro [0,1,2,...] dans la liste en faisant précéder le numéro par un "!". Les valeurs sont mises à jour au fur et à mesure et le pseudo-capteur (0) après le traitement de chaque capteur. Pour éviter qu'un capteur soit pris en direct par le pseudo-capteur, on peut rajouter l'opération clr n'importe où dans la chaîne correspondante.
l'opération time permet de sélectionner le capteur le plus récent. time:val1!cap1:val2!cap2:... Renvoi de la valeur du capteur le plus récent de la liste, la date est décalée de val (minutes) (stamp+val) avant la comparaison et cap fait référence au numéro du capteur dans la liste [!1..!n].
Dans les phases de simulation, les capteurs multiples ne sont pas pris en compte.
Exemples :
```xml [VAR1] -> 1338785,mul:!1 -> 412.09 carré de la valeur pour une valeur initiale de 20.3 [VAR1] -> 1338785,mul:!0 -> 0 pour une valeur initiale de 20.3 (le pseudo-capteur sera initialisé ensuite) [VAR1] -> 1338785,mul:!2 -> 20.3 pour une valeur initiale de 20.3 (le capteur 2 n'existe pas)
pour 2 capteurs indiquant 20.9 et 20.1 [VAR1] -> 1338783;1338799 -> 41 somme des 2 capteurs
[VAR1] -> 1338783;1338799,add:0.2 (correction 0.2°C sur capteur 2) [VAR3] -> div:2 -> 20.6°C moyenne des 2 capteurs [VAR1] -> 1338783;1338799,add:0.2,chs -> 0.6°C ecart des 2 capteurs (après correction du capteur 2) -> x-(y+0.2)
pour 2 capteurs donnant un voltage (x) et un ampérage (y) on peut calculer la puissance apparente : x*y
[VAR1] -> 1338773,clr;1338775,mul:!1 -> x0+yx -> xy , x est calculé et donc utilisable, mais non pris en compte par le pseudo-capteur 0 [VAR1] -> 1338773,mul:!2;1338775,clr -> x0+yx -> xy , y est calculé, mais c'est la valeur initiale qui est prise en compte par le pseudo-capteur !0, car le capteur !2 n'a pas encore été évalué. [VAR1] -> 1338773;1338775,mul:!1,sub:!1 -> x+(yx-x) -> x+xy-x -> xy [VAR1] -> 1338773;1338775,mul:!1,sub:!0 -> x+(yx-x) -> x+xy-x -> xy fonctionne aussi car !0=!1 après le calcul de x
[VAR1] -> 1338785,clr;1338786,sub:32,div:1.8,clr;1754102;0,time:0!1:10!2 -> les capteurs 1338785 et 1338786 sont affectés de l'opération clr pour éviter leur sommation directe, le capteur 1338786 est transformé de Farenheit en Celsius, 0,time:10!1:1!2 L'id de capteur ne sert à rien (mettre n'importe quoi), le temps du capteur !1 (id = 1338785) est avancé de 10 minutes et comparé au temps du capteur !2 (id = 1338785) : Le valeur modifiée du capteur le plus récent est conservée et additionnée au capteur !3 (id = 1754102) ```
V1.0 Version 1.0 éditée le 2024/03/31 (dommarion) version de base : filtres 1 (moyenne) et 2 (FIR); methode dans VAR2 et parametre dans VAR3.
xml
[VAR1] ->3077804 (id_capteur)
[VAR2] ->2 (FIR) ou 1(moyenne)
[VAR3] ->1,2,4,2,1 (Coefficients du FIR ) ou 5 (nombre déchantillons de la moyenne)
V1.1 Version 1.1 éditée le 2024/06/18 (opa95) extension filtres IIR, préfiltrage et préchargement des données. Pour passer à cette version, il est recommandé d'effacer le fichier filtrage.php de la box (ou de le sauvegarder) avant d'installer la nouvelle version, car les variables sauvegardées ne sont pas les mêmes.
Sous-version V1.1.6 : corrections sur le préfiltrage, fenêtre sinus cardinal, le préfiltre med correpond uniquement à med:3
```xml [VAR1] ->3077804 (id_capteur) [VAR2] ->nom;listes (Méthode;L0;L1;L2) [VAR3] ->préfiltre
accepte les valeurs de l'ancienne version [VAR2] ->2 //ou 1(moyenne) [VAR3] ->1,2,4,2,1 //(fir) ou 5 (moyenne) ```
V1.2 Version 1.2 éditée le 2024/07/08 (opa95) extension aux capteurs multiples (accepte les valeurs des versions antérieures).
```xml [VAR1] ->idcapteur1,op11:val11,op12:val12,...;idcapteur2,op21:val21;... [VAR2] ->nom;listes (Méthode;L0;L1;L2) [VAR3] ->préfiltre
[VAR1] ->1549815;1549814; -> somme des valeurs des 2 capteurs
[VAR1] ->1549815;1549814; [VAR3] ->div:2; -> moyenne des valeurs des 2 capteurs
[VAR1] ->1549815;1549814,chs:; différence des valeurs des 2 capteurs [1549815]-[1549814] ```
Les commandes sont envoyées dans les variables [VAR1],[VAR2] et [VAR3]. Le nom de la commande est en minuscules mais le nom de la valeur peut être indifféremment en minuscules ou en majuscules.
[VAR1] contient l'identifiant du capteur (obligatoire)
xml
[VAR1] ->3077804
[VAR2] contient le type de filtre et les parametres : NUL,MOY, FIR, IIR, NUM, ANA, EXP, BUTT,...
nom;période,ordre;B;A; les listes sont composées de valeurs séparées par des "," et les listes sont séparées par des ";". Le ";" immédiatement après le nom (ou numéro du filtre) peut être remplacé par une ","; nom;période,ordre;B;A et nom,période,ordre;B;A sont équivalents.
Pour rester compatible avec la version 1.1, le nom du filtre peut être remplacé par son numéro dans la liste ci-dessus (1 pour moyenne ou 2 pour fir).
Si VAR2 est vide, par défaut, VAR2=nul => pas de filtrage.
Les paramètres du filtre dépendent du type de filtre : en général, 1 à 3 listes séparées par des ";" [L0;L1;L2]), les éléments d'une liste L sont séparés par des virgules (ex : 1,2,1).
La liste L0 comporte le nom du filtre suivi éventuellement de la période de coupure, de l'ordre, du type, du préchargement.
Les listes de coefficients sont ordonnées du poids fort au poids faible et peuvent aussi être entrées sous forme de produits de polynômes (du poids faible au poids faible).
Les filtres prédéfinis ont des meilleurs coefficients, car les décimales ne sont pas arrondies.
Le préchargement permet de saturer le filtre au démarrage, pour éviter une évolution lente jusqu'à la valeur d'équilibre ou lors des changements de paramètres. Si le préchargement est absent, il est activé automatiquement. Le préchargement est codé !n : !0 correspond à la désactivation et !n impose le préchargement de n valeurs identiques; si n est absent !, la valeur est estimée par le script. L'instruction de préchargement est la dernière de L0 ou absente.
Le mode debug permet de vérifier que les commandes ont bien été interprétées.
filtre sans paramètre (tous les filtres peuvent être utilisés sans paramètres, ils utilisent alors des paramètres par défaut ):
filtres utilisant des listes de coefficients :
xml
Exemple :
[VAR2] ->MOY;5 (ou moy;5) // moyenne de 5 entrées équivalent à MOY;5,!5
[VAR2] ->BUTT;5,2 //Filtre Butterworth période de coupure 5, ordre 2 équivalent à BUTT;5,2,!15
[VAR2] ->ANA;5;A //Filtre Analogique période de coupure 5, coefficients A
[VAR2] ->FIR;5;B //Filtre FIR période de coupure 5, coefficients B
[VAR2] ->IIR;5;B;A //Filtre FIR période de coupure 5, coefficients B
Remarque : La valeur !0 permet de retrouver les comportements habituels des filtres, les filtres numériques sont initialisé avec des 0 pour les valeurs des entrées et sorties antérieures au lancement, ce qui conduit à des valeurs initiales proches de 0 et à un tassemant des graphes sortis par l'eedomus.
On peut éviter cet artefact en omettant la commande de préchargement dans la liste L0 ou en initialisant le filtre à partir de la fenêtre de test. Dans ce cas, il suffit d'observer le champ \
Exemples
pour moy(5), une température de 15.5 et une commande &reset=5 , on obtient
simulout -> 3.1,6.2,9.3,12.4,15.5; la première valeur dans le PLUGIN sera 15.5 au lieu de 3.1.
pour butt(5,2), une température de 14.7 et une commande &reset=10 (8 suffirait, mais ça ne coûte rien), on obtient
simulout -> 3.03661,10.231939,15.332804,15.808755,14.985802,14.5885,14.602833,14.685928,14.713827,14.707865; la première valeur dans le PLUGIN sera 14.708 au lieu de 3.037.
Le préchargement automatique permet d'éviter la réinitialisation par un reset. Le préchargement s'effectuera à chaque changement des paramètres : on peut le forcer par exemple en changeant une valeur entière 4 par 4.0 ou inversement cf, ci-dessous).
Les coefficients sont recalculés seulement au lancement ou après une modification de la commande ([VAR2]), même si on change une valeur numérique 2 en 2.0, car les comparaisons des filtres se font caractère à caractère. Les mémoires sont vidées et le filtre sera préchargé à nouveau.
Dans le mode test, on peut utiliser la commande reset pour obtenir la réponse à un signal donné. Si on utilise un préfiltre ne correspondant pas à une opération directe, il se peut que les premières valeurs soient faussées car elles peuvent utiliser des valeurs antérieures qui n'existent pas (le,lt,ge,gt,dmax,med,moy:n[n-1 premières valeurs fausses]).
Exemples :
-Réponse indicielle : reset=n;1 : envoi de n valeurs "1"; reset=n envoi n fois la valeur du capteur, on obtient la réponse indicielle multipliée par la valeur actuelle du capteur (constante).
xml
Réponse indicielle d'un filtre de Butterworth (butt;5;4) récupérée dans la fenêtre de test **reset=20;1**.
<SimulIn0>1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1</SimulIn0>//Valeurs en entrée du préfiltre
<SimulIn>1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1</SimulIn>//Valeurs en entrée du filtre
<SimulOut>0.05,0.27,0.69,1.06,1.16,1.04,0.95,0.96,1,1.02,1.01,0.99,0.99,1,1,1,1,1,1,1</SimulOut>//Valeurs de sortie (gain 1).
-Réponse impulsionnelle : reset=1;1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 : envoi de 1 valeur "1" et 19 "0";
xml
Réponse impulsionnelle d'un filtre de Butterworth (butt;5;4).
<SimulIn0>1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0</SimulIn0>//Valeurs en entrée du préfiltre
<SimulIn>1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0</SimulIn>//Valeurs en entrée du filtre
<SimulOut>0.05,0.22,0.42,0.37,0.09,-0.11,-0.09,0.01,0.05,0.02,-0.01,-0.01,-0,0.01,0,-0,-0,-0,0,0</SimulOut>//Valeurs de sortie
-Réponse fréquentielle (f=fe/2 = fréquence de Nyquist, T=2 min) : reset=10;1,-1 : envoi de 10 séquences "1,-1";
xml
Réponse fréquentielle d'un filtre de Butterworth (butt;5;4).
<SimulIn0>1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1</SimulIn0>//Valeurs en entrée du préfiltre
<SimulIn><SimulIn>1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1,1,-1</SimulIn>//Valeurs en entrée du filtre
<SimulOut>0.05,0.18,0.25,0.13,-0.04,-0.08,-0.02,0.03,0.02,-0,-0.01,-0,0,0,-0,-0,-0,0,0,0</SimulOut>//Valeurs de sortie (gain 0, déphasage -360°).
-Réponse fréquentielle (f=fe/4,T=4 min) : reset=5;0,1,0,-1 : envoi de 5 séquences "0,1,0,-1";
xml
Réponse fréquentielle d'un filtre de Butterworth (butt;5;4) récupérée dans la fenêtre de test.
<SimulIn>0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1,0,1,0,-1</SimulIn>//Valeurs en entrée du filtre
<SimulOut>0,0.05,0.22,0.38,0.15,-0.28,-0.26,0.19,0.27,-0.14,-0.25,0.13,0.24,-0.13,-0.23,0.13,0.23,-0.13,-0.23,0.14</SimulOut>//Valeurs de sortie (gain 0.27, déphasage -330°).
-Réponse fréquentielle (f=fe/5,T=5 min = Tc du Butterworth) : reset=5;0,1,0,-1 : envoi de 3 séquences "0,0.95,0.59,-0.59,-0.95";
xml
Réponse fréquentielle d'un filtre de Butterworth (butt;5;4) récupérée dans la fenêtre de test.
<SimulIn>0,0.95,0.59,-0.59,-0.95,0,0.95,0.59,-0.59,-0.95,0,0.95,0.59,-0.59,-0.95,0,0.95,0.59,-0.59,-0.95</SimulIn>//Valeurs en entrée du filtre
<SimulOut>0,0.04,0.24,0.5,0.43,-0.15,-0.63,-0.33,0.44,0.64,-0.02,-0.67,-0.4,0.42,0.67,-0,-0.67,-0.41,0.42,0.67</SimulOut>//Valeurs de sortie (gain 0.7, déphasage -180°).
-Réponse fréquentielle (f=fe/8, T=8 min) : reset=3;0,0.707,1,0.707,0,-0.707,-1,-0.707 : envoi de 3 séquences "0,0.707,1,0.707,0,-0.707,-1,-0.707";
xml
Réponse fréquentielle d'un filtre de Butterworth (butt;5;4) récupérée dans la fenêtre de test.
<SimulIn>0,0.707,1,0.707,0,-0.707,-1,-0.707,0,0.707,1,0.707,0,-0.707,-1,-0.707,0,0.707,1,0.707,0,-0.707,-1,-0.707</SimulIn>//Valeurs en entrée du filtre
<SimulOut>0,0.03,0.2,0.55,0.84,0.7,0.07,-0.67,-1.01,-0.73,-0.01,0.71,1,0.7,0,-0.7,-0.99,-0.71,-0,0.7,0.99,0.71,0,-0.7</SimulOut>//Valeurs de sortie (gain 1, déphasage 0°).
Les commandes complémentaires sont dans la requête HTTP
&maxtime=300&prec=2Passer en mode test et mettre les commandes directement en fin de ligne de commande. Si on veut faire des essais rapprochés, on a intérêt à autoriser des lectures rapprochées en modifiant la commande maxtime=60 en maxtime=1 (1 seconde).
reset -> [0 , 1, -1] (0 par défaut) réinitialisation des mémoires &reset=1 et lecture du capteur; si &reset=-1, même comportement mais réinitialisation du préfiltre en plus.
reset -> n (n entier <> 0) réinitialisation des mémoires et ininitialisation du filtre avec n valeurs identiques à la dernière valeur du capteur &reset=5 correspond à l'envoi successif de 5 fois la valeur du capteur; s'il y a des prétraitements, ils sont effectués avant; si n négatif, même comportement mais réinitialisation du préfiltre en plus.
reset -> n;V1,V2,... (n entier >=1) reinitialisation des mémoires et ininitialisation du filtre avec n fois la séquence V1,V2,... &reset=10;1 correspond à l'envoi successif de 10 fois la valeur 1 (Réponse indicielle); s'il y a des prétraitements, ils sont effectués avant. La réponse impulsionnelle,s'obtient avec reset=2;1,0,0,0,0,0,0,0,0,0..., avec un nombre de 0 suffisants pour que la sortie devienne stable; si n négatif, même comportement mais réinitialisation du préfiltre en plus. La séquence V1,V2,... est passée une fois dans le préfiltre.
reset -> 1;init_dir réinitialisation des mémoires et initialisation avec les valeurs init_dir si (filtre IIR) reset=1;1,1,1,1,1 correspond à l'envoi successif de 5 fois la valeur 1 (réponse indicielle); s'il y a des prétraitements, ils sont effectués avant. reset=1;1,0,0,0,0 renvoie les 5 premiers termes de la réponse impulsionnelle. Pour un filtre IIR, la réponse indicielle s'obtient avec reset=10;1 (10 premiers termes).
debug -> [0 , 1] (0 par défaut, pas de débogage) affichage de divers paramètres et suivi du déroulement du calcul (à éviter avec un reset ou simule long). Le XPATH reste valide.
delete -> [0 , 1] (0 par défaut, pas deffacement) Efface les mémoires du PLUGIN et arrêt : delete=1.
xml
&debug=1 (dans la chaine de commande)
Sortie à l'initialisation
xml
//methode=butt
//parametre=10,5
//reset=0, mais auto recharge équivalent à reset=30
//renvoi XML
<?xml version="1.0" encoding="UTF-8"?>
<!-- Debug Filtrage V1.1.6
/Debug -->
<root>
<Value>20.8</Value>
<Last>2024-06-18 11:06:28</Last>
<Methode>butt;10,5</Methode>
<Methode_>butt;10,5,!;;</Methode_>
<EntreeBrute>20.8</EntreeBrute>
<Direct>0.001283,0.006413,0.012826,0.012826,0.006413,0.001283</Direct>
<Reverse>1,-2.975422,3.806018,-2.545253,0.88113,-0.125431</Reverse>
<Parametres>0.001283,0.006413,0.012826,0.012826,0.006413,0.001283;1,-2.975422,3.806018,-2.545253,0.88113,-0.125431</Parametres>
<SimulIn0>20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8</SimulIn0>
<SimulIn>20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8,20.8</SimulIn>
<SimulOut>0,0.2,1,2.9,6.2,10.6,15.3,19.4,22.3,23.6,23.6,22.7,21.5,20.4,19.9,19.8,20.1,20.5,20.9,21.1,21.2,21.1,21,20.8,20.7,20.6,20.7,20.7,20.8,20.8</SimulOut>
</root>
</root>
Sortie en cycle normal
xml
//methode=butt
//parametre=10,5
//renvoi XML
<?xml version="1.0" encoding="UTF-8"?>
<!-- Debug Filtrage V1.1.6
/Debug -->
<root>
<Value>20.9</Value>
<Last>2024-06-18 11:09:11</Last>
<Methode>butt;10,5</Methode>
<Methode_>butt;10,5,!;;</Methode_>
<EntreeBrute>20.9</EntreeBrute>
</root>