Bonjour  
Je cherche à programmer un regulateur de flux de données (par un PID).
J'ai des données qui arrivent d'un coté (de maniere plus ou moins reguliere),
 je les ressort de l'autre. La sortie doit être reguliere , ne doit pas presenté d'acoup,  
il faut eviter les petites fluctuations, elle doit rattrape un retour s'il y a.
L'objectif est d'avoir le sortie la plus fluide possible.
Merci d'avance
   

Et donc, quelles idées as tu pour le moment?

J'ai fait un rattrapage et regulation lineaire, par palier, mais ca saccade

et pour le retard, tu comptes faire quoi ? ton système ne sera pas temps réel, si rien ne t'oblige à faire du périodique en contrôle de processus, c'est pas mal d'avoir un retard borné quand même.
 
plus sérieusement, tu fais un accumulateur pour l'intégrateur (à 2 compteurs, comme expliqué par Kahan), tu notes la dernière valeur pour la dérivée, tu notes la date à laquelle tu as pris la dernière valeur, et en voiture Simone, out=p+i+d.

Ou est ce que je peux trouver la formule de Kahan ( algorithme si possible en java).
merci d'avance

http://www.google.fr/search?q=algo [...] unofficial
 
la vache nraynal

oué, je vais lui filer direct
 
tu as ton accumulateur s qui sera l'intégrale du signal de 0 à maintenant, et es, l'erreur lors du dernier calcul de s. s et es sont conservées d'un tour à l'autre.
in c'est la nouvelle valeur de l'entrée, t le temps écoulé depuis la dernière mesure :
 

 
s et es auront comme valeur initiale zéro.
 
pour expliquer : quand la somme devient grande, on a la valeur d'entrée qui devient très inférieure à la somme, l'addition perd donc une tonne de bits, si on additionne direct l'ancienne somme avec la nouvelle valeur.
 
on a une estimation de l'erreur au coup précédent, on soustrait cette erreur non pas à la somme (l'erreur est plutôt petite) mais à la valeur d'entrée (qui a une taille plus comparable à l'erreur), puis on ajoute cette valeur "corrigée" à la somme. Ensuite, on calcule l'erreur qu'on a faite lors de cette dernière opération. s - sPrec représente la valeur d'entrée accompagné de l'erreur qu'on a faite lors de in+s (parce que si s>> temp, on a s~sPrec, donc cette soustraction est juste) on soustrait l'erreur précédente (déjà corrigée) et la valeur d'entrée pour retrouver l'erreur faite au dernier coup.
 
voiloù, c'est plus complexe que la simple addition, mais c'est très important, un intégrateur dérive très vite en pratique.

quand je regarde es il vaut toujours 0 ce qui est logique au vue du code
 
Voila un exemple de mon probleme :
tour 1 : 200 valeurs en stock j'en consomme x1 en t1 (X1 <200)
tour 2 : 250 valeurs en stock j'en consomme x2 en t2 (X2 <250) le stock a augmenté car j'ai eu plus d'apport que de consommé
tour 3 : 220 valeurs en stock j'en consomme x3 en t3 (x3 <220) le stock a diminue car j'ai eu moins d'apport que de consommé
tour 4 : 180 valeurs en stock j'en consomme x4 en t4
tour 5 : 210 valeurs en stock j'en consomme x5 en t5
tour 6 : 210 valeurs en stock j'en consomme x6 en t6
......
 
ce que je cherche c'est à reguler les x consommés pour que mon stock soit quasi nul, et que les x que je consomme ne varie pas trop rapidement car ma sortie (x ) doit etre fluide.
 
J'espere que j'ai reussi à vous presenter mon probleme.
Cordialement.
 
 
 
 

heu, tu as utilisé des entiers ???

non
mais :  
es = (s - sPrec ) - temp;  
avec s = SPrec+temp
on a bien es =0;
 
Une petite question est ce que mon exemple est clair ?
 

oui, mais là on est dans le monde de la précision limitée, comme sPrec >> in (car l'intégrale est très suppérieure à la valeur) on a une grosse perte de précision dans l'addition. Donc toutes les égalitées n'en sont pas.
 
C'est par exemple à cause d'un truc comme ça (enfin, approchant) qu'un partriot a raté un scud irakien.

http://forum.hardware.fr/hardwaref [...] tm#t563814
un exemple de perte de précision.

en fait, si j'insiste sur cette formulation de l'intégrale, c'est pas pour pinailler.
 
Le coefficient intégral de la correction sert à corriger les très petites erreurs de position dans le système (souvent des frottements et jeux). Il ne s'agit donc pas d'avoir une intégrale fausse, vu qu'elle est justement destinée à corriger de petites variations.

dans :  
 
float tin = t*in;  
float temp = tin - es;  
float sPrec = s; // somme au coup précédent  
s += temp; // nouvelle somme corrgiée de toutes les erreur précédentes.  
es = (s - sPrec ) - temp; // nouvelle erreur
 
 
Je ne vois pas l'intégrale ?
Est ce que je peux te telephoner mercredi dans la matinée ??
merci
 
 
 
 

l'integrale c'est le s ??

 
oui, l'intégrale de 0 à maintenant de l'entrée c'est le s.