13 réponses à ce sujet

[xav12358]

Tout d'abord bonjour à tous et à toutes,

Je suis nouveau sur ce forum, je suis étudiant en éléctronique.

Je voulais poser une question car j'ai un soucis d'intégration de données sur un projet.
J'ai plusieurs vitesses de déplacement qui me viennent de différent capteur et je voudrais les intégrer.
J'ai deux capteurs avec des fréquences d'acquisition différentes donc un des capteurs qui me fournit les données de manière asynchrone.

J'ai donc un capteur c1 qui me donne des données de vitesse v1 etun capteur c2 qui me donne des données de vitesse v2.

Je voudrais intégrer ces deux vitesses instantanées pour obtenir une position et voici mon programme:


Initialisation:
Posx = 0
Posy = 0
tref = 0


si(c1 a une donnée) alors
tnow = donnedate
Posx+ = (tnow-tref)*v1x
Posy+ = (tnow-tref)*v1y
finsi

si(c2 a une donnée) alors
tnow = donnedate
Posx+ = (tnow-tref)*v2x
Posy+ = (tnow-tref)*v2y
finsi


Voila, il faut dire que je ne tiens pas compte des rotations éventuelles et j'ai fait l'hypothese que j'obtenais les données dans le même référenciel.

Quelqu'un pourrait me dire si ma démarche est bonne?

D'avance merci.

[olivthill]

Pourquoi avoir deux capteurs ? Au début, je ne comprenais pas jusqu'à ce que j'arrive à imaginer qu'il y en aurait un pour un déplacement en x, et un pour un déplacement en y. Mais en voyant les calculs dans le programme, il semble que cette hypothèse ne soit pas correcte. Si on avait plus d'informations sur les déplacements (en ligne droite uniquement, ou aussi sur tout un plan, et avec ou sans montée, avec ou sans accélération), et plus d'informations sur la disposition des capteurs, cela aiderait à comprendre le problème.

Par ailleurs, le mot "intégration" a plusieurs sens.
Ici, il semble qu'il s'agise de son sens mathématique.
Si, je comprends bien, il faudrait connaître la position en fonction de deux vitesses.
Donc, il faudrait appliquer les formules :

nouvelle position en X = vitesse en X *(écart de temps) + ancienne position en X
nouvelle position en Y = vitesse en Y *(écart de temps) + ancienne position en Y

Cela ressemble à ce qui est écrit dans le programme, sauf que je ne comprends pas bien pourquoi les deux déplacements sont impactés par les vitesses mesurées par les deux capteurs à la fois.

[xav12358]

En fait j'imagine qe j'ai deux capteurs qui me donne la meme information mais à intervalle de temps complétement différents. Ces deux capteurs me donnent la meme information, c'est a dire les vitesses vx et vy.

Mon problème est de savoir comment fusionner ces deux données capteurs.

L'equation je la connais effectivement,c'est ce que j'ai fait dans mon algorithme. Mon problème est de savoir à quoi correspond cette "écart de temps" dans la mesure ou j'ai deux capteurs qui ont des temps d'acquisition completement différent.

J'avais oublié quelque chose dans mon algo, le voici modifié:

Initialisation:
Posx = 0
Posy = 0
tref = 0

while(1)

si(c1 a une donnée) alors
tnow = donnedate
Posx+ = (tnow-tref)*v1x
Posy+ = (tnow-tref)*v1y
tref = donnedate
finsi

si(c2 a une donnée) alors
tnow = donnedate
Posx+ = (tnow-tref)*v2x
Posy+ = (tnow-tref)*v2y
tref = donnedate
finsi

finwhile

[xav12358]

Personne pour me répondre ?

Pourtant je suppose que ca doit être une question basique quand on fait de la fusion des données ? Nan?

[Mike118]

Personne pour me répondre ?

Pourtant je suppose que ca doit être une question basique quand on fait de la fusion des données ? Nan?

En fait tu peux le faire de plusieurs façons...
Si tu as deux capteurs qui te retournent la même information une méthode simple est de faire une moyenne plus ou moins pondérée de tes capteurs... Si tu en as un qui est censé être plus précis tu fais en sorte que ce dernier soit prépondérant ...
Après tu peux aussi prendre plusieurs valeur sur un intervale de temps fini, virer la plus haute, virer la plus passe, faire la moyenne des autres ...
En réalité tu peux appliquer n'importe quel modèle de fusion de données ... après ils seront plus ou moins utile et représentatif de la vérité.

Quand tu as des capteurs qui te retourne des informations de nature différentes il faut traiter les donner de manière à leur donner une nature identique dans la fusion. ( exemple si tu as un Girometre et un compas, tu vas intégrer la valeur donné par le giro et voir si ça correspond à la valeur du compas ... )

[xav12358]

Je crois que je me suis mal fait comprendre depuis le début.

Je n'ai pas de problème pour filtrer les signaux (filtre passe bas,...). Supposons que les signaux sont bon et qu'ils n'ont pas d'erreur mais qu'il donne la même information mais a des intervalles de temps différents.

Normalement pour intégrer une position on intégre les vitesse pour un capteur ca donne:

p(t) = p(t-1) + deltaT*v(t) ou deltaT est la fréquence d'acqusition de la données genre 10ms.

mais dans le cas ou on fusionne deux capteurs qui donne deux vitesses (à fréquence d'acquisition de 20 et 30ms) ca va donner quoi?
p(t) = p(t-1) + deltaT1*v1(t)
et p(t) = p(t-1) + deltaT2*v2(t)

Mais dans ce cas deltaT1 et deltaT2 ne vaudra pas 20 et 30ms ? Pour moi ca doit valoir la durée depuis la derniere fusion...
C'est a dire pour intégrer la vitesse du capteur c2 si depuis la derniere intégration il s'est passé 5ms deltaT2 vaudra 5ms et pas 30ms. Ai-je raison?
Sinon pour moi la position p(t) ne sera pas correcte si on carte deltaT1 et deltaT2 égaux à 20 et 30ms.

J'espere que j'ai été plus clair...

[R1D1]

Je n'ai pas de problème pour filtrer les signaux (filtre passe bas,...). Supposons que les signaux sont bon et qu'ils n'ont pas d'erreur mais qu'il donne la même information mais a des intervalles de temps différents.

Dans ce cas, quel est l'intérêt d'avoir deux fois la même information ? Pourquoi ne pas garder uniquement le capteur qui sample le plus vite ?

Normalement pour intégrer une position on intégre les vitesse pour un capteur ca donne:

p(t) = p(t-1) + deltaT*v(t) ou deltaT est la fréquence d'acqusition de la données genre 10ms.

En général, on évite. Pour avoir essayé d'appliquer ce genre de méthode sur des accélérations pour remonter à la position, le résultat est très mauvais : tu intègres deux fois le bruit, et ta position finit par dériver.

mais dans le cas ou on fusionne deux capteurs qui donne deux vitesses (à fréquence d'acquisition de 20 et 30ms) ca va donner quoi?
p(t) = p(t-1) + deltaT1*v1(t)
et p(t) = p(t-1) + deltaT2*v2(t)

Mais dans ce cas deltaT1 et deltaT2 ne vaudra pas 20 et 30ms ? Pour moi ca doit valoir la durée depuis la derniere fusion...

Soit tu fais l'hypothèse que le phénomène mesuré est stationnaire dans la période de mesure la plus longue, auquel cas, considérer que v2(t) = v2(t+1) peut marcher si ton processeur est plus rapide que ta mesure. Soit tu ne mesures l'information qu'aux périodes adéquates (donc v1 toutes les 20ms, v2 toutes les 30ms) et tu ne fusionnes que quand tu as deux mesures.
Sinon, la solution la moins bricolée est probablement d'utiliser un filtre de Kalman avec ton capteur le plus rapide pour mettre à jour le modèle et le plus lent comme observation qui vient corriger l'erreur accumulée par le premier. Une recherche Kalman / fusion de capteurs te renvoie des résultats intéressants (ne serait-ce que le site d'un certain F. Piette ).

[Black Templar]

Hello

Je n'ai pas de problème pour filtrer les signaux (filtre passe bas,...). Supposons que les signaux sont bon et qu'ils n'ont pas d'erreur mais qu'il donne la même information mais a des intervalles de temps différents.

[...]

mais dans le cas ou on fusionne deux capteurs qui donne deux vitesses (à fréquence d'acquisition de 20 et 30ms) ca va donner quoi?
p(t) = p(t-1) + deltaT1*v1(t)
et p(t) = p(t-1) + deltaT2*v2(t)

Mais dans ce cas deltaT1 et deltaT2 ne vaudra pas 20 et 30ms ? Pour moi ca doit valoir la durée depuis la derniere fusion...
C'est a dire pour intégrer la vitesse du capteur c2 si depuis la derniere intégration il s'est passé 5ms deltaT2 vaudra 5ms et pas 30ms. Ai-je raison?
Sinon pour moi la position p(t) ne sera pas correcte si on carte deltaT1 et deltaT2 égaux à 20 et 30ms.

Tout à fait. Je n'ai pas lu les premiers posts, mais si tu es sûr de tes mesures, et que tu as la connaissance de l'intervalle de temps entre deux mesures, alors tu peux utiliser ta méthode.
Tu n'a alors qu'une seule formule :
p(t) = p(t-1) + (temps_actuel - temps_dernière_acquisition) * v_capteur_1_ou_2(t)

Dans ce cas, quel est l'intérêt d'avoir deux fois la même information ? Pourquoi ne pas garder uniquement le capteur qui sample le plus vite ?

ça permet de mettre a jour plus souvent la position, donc tu as plus d'infos qu'uniquement avec un seul capteur. Vu que tu ne fais qu'intégrer, avec une fréquence d'échantillonnage variable n'est pas un soucis.
Bon, par contre, tu auras forcement une dérive au bout d'un moment

Sinon, la solution la moins bricolée est probablement d'utiliser un filtre de Kalman avec ton capteur le plus rapide pour mettre à jour le modèle et le plus lent comme observation qui vient corriger l'erreur accumulée par le premier. Une recherche Kalman / fusion de capteurs te renvoie des résultats intéressants (ne serait-ce que le site d'un certain F. Piette ).

Huhu, bien vu. Mais je pense qu'appliquer un Kalman dans ce cas, c'est sortir la grosse bertha pour pas grand chose. Vu qu'on a aucune info sur le modèle d'évolution et que les capteurs fournissent des informations identiques, un Kalman n'apporterai pas grand chose par rapport à une simple moyenne...

[xav12358]

Merci Black Templar d'avoir enfin compris mon problème.

Donc en fait quand on voit des filtres de kalman (ou d'autre algo) ou on considère que deltaT est toujours égale a la fréquence d'acquisition du signal c'est faux ?

Je prend un autre exemple, je veux fusionner une donné de vitesse que je connais et une donné d'accélération que j'ai. J'ai deux capteurs c1 pour la vitesse et c2 pour l'accéléromètre avec des fréquences d'acquisitions différentes ca donnerait:

%% Initialisation
vk =0

tref = timenow;

while(1)
if(c1)
{
vk = vk + alpha1*vc1;
tref = timenow
}

if(c2)
{
vk = vk + alpha2*(time -tref)*ac1
tref = timenow
}

Ou alpha1 et alpha2 sont les coefficients de confiance des capteurs tel que alpha1 + alpha2 =1.

Je me suis trompé ?

Pour la question de R1D1 concernant l'intérêt de fusionner deux capteur qui donne la même donnée. Les deux capteurs peuvent avoir en pratique des écart types différents et donc dans le cas de l'utilisation du filtre de Kalman si sigma1 et 2 correspondent aux capteurs 1 et 2,on aura:
sigmaf = f(sigma1,sigma2) < min(sigma1,sigma2).

D'apres ce que j'ai cru comprendre ...

[Black Templar]

Donc en fait quand on voit des filtres de kalman (ou d'autre algo) ou on considère que deltaT est toujours égale a la fréquence d'acquisition du signal c'est faux ?

Dans u filtre de Kalman (ou dans la majorité des algos de fusions), la fréquence d'échantillonnage est fixe. Autrement dit, tu as toutes des mesures en même temps, à intervalle régulier X fois par secondes.
Mais on peut toujours trouver des astuces dans le cas où les fréquences d'échantillonnages sont différentes selon les capteurs (inter ou extrapolation par exemple)

Je prend un autre exemple, je veux fusionner une donné de vitesse que je connais et une donné d'accélération que j'ai. J'ai deux capteurs c1 pour la vitesse et c2 pour l'accéléromètre avec des fréquences d'acquisitions différentes ca donnerait:

%% Initialisation
vk =0

tref = timenow;

while(1)
if(c1)
{
vk = vk + alpha1*vc1;
tref = timenow
}

if(c2)
{
vk = vk + alpha2*(time -tref)*ac1
tref = timenow
}

Ou alpha1 et alpha2 sont les coefficients de confiance des capteurs tel que alpha1 + alpha2 =1.

Je me suis trompé ?

Nop ! ça ne marchera pas. Tu ne peux pas appliquer des coef de confiance dans ce cas là.
Tu aurais pu si tu avais deux mesures de vitesses qui arrivent en même temps. Dans ce cas, tu aurais fait une moyenne pondérée par les coef de confiances afin d'obtenir une vitesse résultante que tu aurais pu intégré pour obtenir la position.

Dans ton cas, ça ne marche pas car tu as des images de la vitesses à des instants différents.

D'autre part, il y a quelques erreurs dans l'algo :

if(c1)
 	{
   	vk = vk + alpha1*vc1;
   	tref = timenow
 	}

si tu fais vk = vk + quelquechose, tu intègres la vitesse. et le quelque chose doit forcement être le produit d'une accélération par un temps.
Ici, vk = vc1 tout simplement. (mais dans ce cas, pas de fusion !)

Pour la question de R1D1 concernant l'intérêt de fusionner deux capteur qui donne la même donnée. Les deux capteurs peuvent avoir en pratique des écart types différents et donc dans le cas de l'utilisation du filtre de Kalman si sigma1 et 2 correspondent aux capteurs 1 et 2,on aura:
sigmaf = f(sigma1,sigma2) < min(sigma1,sigma2).

if(c2)
 	{
      vk = vk + alpha2*(time -tref)*ac1
      tref = timenow
 	}

Ici, c'est le problème que j'ai énoncé plutôt : tu ne peux pas pondérer par alpha2 car dans ces cas là, tu fausse la mesure vu que tu ne peux pas sommer par la seconde mesure pondérée par alpha1...

Pour la question de R1D1 concernant l'intérêt de fusionner deux capteur qui donne la même donnée. Les deux capteurs peuvent avoir en pratique des écart types différents et donc dans le cas de l'utilisation du filtre de Kalman si sigma1 et 2 correspondent aux capteurs 1 et 2,on aura:
sigmaf = f(sigma1,sigma2) < min(sigma1,sigma2).

D'apres ce que j'ai cru comprendre ...

Là j'ai pas compris.

[xav12358]

Concernant la variance de la valeur estimée j'ai un document pour l'expliquer à la page 64 figure 1.6:

http://www.cs.unc.ed...ursePack_08.pdf

On voit que la variance du résultat est inférieure aux valeurs des deux données d'entrée.

Pour le code je me suis trompé, je voulais le faire sur la position, je recommence:

%% Initialisation
pk =0

tref = timenow;

while(1)
if(c1)
{
pk = pk + alpha1*vc1*(timenow-tref);
tref = timenow
}

if(c2)
{
pk = pk + alpha2*(time -tref)^2/2*ac1
tref = timenow
}

C'est mieux ?

[Black Templar]

Pour le code je me suis trompé, je voulais le faire sur la position, je recommence:

%% Initialisation
pk =0

tref = timenow;

while(1)
if(c1)
{
pk = pk + alpha1*vc1*(timenow-tref);
tref = timenow
}

if(c2)
{
pk = pk + alpha2*(time -tref)^2/2*ac1
tref = timenow
}

C'est mieux ?

N'oublie pas de mettre ton code entre balise [ code] et [/ code], c'est plus lisible comme ça ^^

Sinon, pour le code en question, c'est nickel maintenant. Plus de problèmes (mis à part dans la condition c2, il faut remplacer time par timenow

[Leon]

Je me permet de réagir là dessus. C'est bien beau les math, mais il faut connaitre la physique qui se cache derrière. Or, tu ne nous dit absolument rien de tes capteurs. De quel type de capteur s'agit-il?

Certains capteurs sont performants pour estimer des vitesses/mouvements rapides, mais dérivent rapidement. C'est le cas des accéléros.
D'autres capteurs savent estimer une vitesse/position fiable dans sur un temps relativement long, mais ne donnent rien de fiable sur les variations "court terme". Je pense aux GPS par exemple.

Si c'est ton cas, alors il faut changer de stratégie à mon avis, et passer à du vrai traitement du signal, avec des filtres simples (passe haut, passe bas, passe bande), ou plus complexes (khalman) mais ça peut être rapidement une usine à gaz.

Pour finir, tu dis que tes informations sont fiables. Mais si c'était le cas, aurais-tu vraiment besoin de 2 sources d'information différente? Si c'était le cas, il te suffirait de prendre les infos uniquement du capteur le plus rapide.

Leon.

[xav12358]

C'était purement théorique, je n'ai pas deux capteurs qui captent de vitesse. C'etait juste pour savoir quelle serait la valeur de deltaT en fonction de différents capteurs ayant des temps d'acquisition complétement différents.

Pour compenser l'imprécision du capteur d'accélération notamment il y a les coefficients alpha1 et alpha2.
Comme dans ce lien qui explique comment intégrer les données gyros et accéléros pour faire une centrale inercielle: http://www.starlino.com/imu_guide.html

On fusionne les données de gyro et d'accéléros pour une estimation de la position angulaire :

Rest(n) = (Racc * w1 + Rgyro * w2 ) / (w1 + w2)
Rest(n) = (Racc * w1/w1 + Rgyro * w2/w1 ) / (w1/w1 + w2/w1)
Rest(n) = (Racc + Rgyro * wGyro ) / (1 + wGyro) = alpha1* Racc + RGyro*alpha2 avec alpha1+alpha2 =1