Discussion :

[Seb.26]

Bonjour @ tous

bon, j'ai un souci ( mais vous devez probablement vous en douter, non ? )

J'ai un programme qui tourne sur un PC, et qui alimente 2 modules électroniques via des FIFOS ( peut importe de quoi il s'agit ) chacun de ces modules consomme en fait le flux de données qui est généré par 2 autres modules ...

En gros, ça donne ça :

Les producteurs (P1 & P2) envoient des données à une fréquence donnée ( horloge hard )

Les consommateurs (C1 & C2) prennent les données à une fréquence donnée ...

J'ai besoin que les 2 consommateur restent synchronisés ... et c'est pas le cas aujourd'hui, j'ai un de mes consommateurs dont l'horloge varie un peu ( température, dérive du quartz ... )

Je cherche donc avec l'utilisation d'un PC à pouvoir fabriquer/supprimer les données de l'une des 2 lignes pour que ça reste synchro ...

Tout cela me fait penser à une boucle d'asservissement et à de l'interpolation de données ...

Pour l'interpolation, pas de souci, je vais commencer pas une bête interpolation linéaire, puis probablement mettre une courbe de Bezier à la place ensuite ...

Mais pour l'asservissement, je rame ...

A ma disposition, j'ai le delta t entre mes 2 consommateurs ( en ms )

Et je voudrais trouver un algo qui me donne un coef qui m'indiquerait combien d'échantillons je dois supprimer/fabriquer dans les FIFO du consommateur en cause pour que le consommateur 1 rattrape/attende le consommateur 2 ...

Ce coef devra être ajusté en temps réel avec une pente max assez faible ( pas de variation brusques ) ...

Voilà, si ça vous dis quelque chose ...

Merci,
Have fun !
Seb.

[Seb.26]

... On dirait que mon sujet ne vous inspire pas beaucoup ...

J'ai continuer à y réfléchir, et j'ai tenté de modéliser tout ça un peu plus clairement ...

Donc, en fait, j'ai un flux de données qui entre dans une FIFO sous la forme de paquets de 'x' échantillons, chaque paquet dispose d'un TimeStamp local.

J'ai ensuite un autre flux (2) qui me donne le timestamp (local aussi) de référence
NB: C'est en fait le timestamp du paquet d'échantillons du flux 2 quand il "sort" du PC ...

Donc pour être clair, le flux 2 indique << Je viens d'envoyer les données de l'heure 'xxx' >> ...

Donc pour que le flux 1 reste synchrone avec le flux 2, il va falloir ajouter/supprimer des échantillons du flux 1 ... les flux sortant étant continus et devant le rester ...

Je cherche donc un algo qui va me donner à l'instant 't' combien d'échantillons du flux 1 je devrais ajouter/supprimer pour que le flux 1 "tende "à rester synchro avec le flux 2 ...

Le tout en temps réel car les horloges des consommateurs varient dans le temps ...

Donc c'est de l'asservissement je pense ...

Mais je sèche pour le "comment faire"

Si vous aviez juste même une piste

Merci.
@++
Seb.

[pseudocode]

Bon. Meme avec le 2eme post ce n'est pas plus clair pour moi.

Tu as 2 consomateurs qui consomment, à des intervalles differents, des valeurs générées à un intervalle régulier.

Par exemple, si le consomateur n°2 est 2 fois plus lent que le n°1 on aurait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
-- Temps t=0 -------------
 
[FIFO1]: 6 5 4 3 2 1 
[FIFO2]: 6 5 4 3 2 1 
 
Conso1: FIFO1.pop() -> 1
Conso2: rien
 
-- Temps t=1 -------------
 
[FIFO1]: 7 6 5 4 3 2 
[FIFO2]: 7 6 5 4 3 2 1 
 
Conso1: FIFO1.pop() -> 2
Conso2: FIFO1.pop() -> 1
 
-- Temps t=2 -------------
 
[FIFO1]: 8 7 6 5 4 3
[FIFO2]: 8 7 6 5 4 3 2
 
Conso1: FIFO1.pop() -> 3
Conso2: rien
 
-- Temps t=3 -------------
 
[FIFO1]: 9 8 7 6 5 4
[FIFO2]: 9 8 7 6 5 4 3 2
 
Conso1: FIFO1.pop() -> 4
Conso2: FIFO2.pop() -> 2

c'est ca ?

[Graffito]

Bonjour,

Peux-tu connaitre à tout moment la taille de la FIFO du flux sortant ?

Si oui, on peut utiliser un coef d'ajustement X des flux entrant et sortant (au départ: X=1), puis calculer sur la derniére période (intervalle de temps T) le rapport Y = flux sortant/flux entrant et si X est "assez" différent de Y, X sera modifié pour s'adapter à Y (exemple: X=Y ou X=(X+Y)/2 ou ...)

[Seb.26]

Bonsoir

merci de votre présence

Bon je crois que même avec le second post, c'est loin d'être clair !

Alors,

Tout d'abord, j'ai un producteur 1 et un consommateur 1.
Eux sont parfaitement synchronisés ( le consommateur 1 "consomme" exactement à la vitesse que le producteur 1 "produit" )

Leur flux ( producteur 1 -> consommateur 1 ) est simplement bufferisé ( FIFOS ) par paquet d'échantillons auquel je colle un timestamp à la réception.
J'utilise le timestamp du paquet que j'envoie dans le consommateur 1 comme horloge de référence.

C'est pour moi le << On en est à ... ms >>

Maintenant, j'ai le producteur 2 qui produit de façon régulière des paquets d'échantillons auquel je colle aussi un timestamp lors de la réception.

Mon problème vient du consommateur 2 qui lui "consomme" à une fréquence approximative. Cette fréquence devrait osciller autours d'une valeur, proche de la fréquence de production du producteur 2.

Je veux donc adapter la taille des paquets ( nbr d'échantillons ) qui sortent vers le consommateur 2 de façon à corriger le débit du consommateur 2.

Pour moi, la variable à calculer est 'x', avec x qui est le nombre ( positif ou négatif ) d'échantillons à ajouter/supprimer du paquet d'échantillons juste avant de l'envoyer dans le consommateur 2.

Pour déterminer ce nombre 'x', j'ai à ma disposition les timestamp des paquets que je m'apprête à envoyer dans les 2 consommateurs.

Voilà, j'espère que c'est plus clair !!!

Merci,
@++
Seb.

[Graffito]

Graffito: Peux-tu connaitre à tout moment la taille de la FIFO du flux sortant ?

C'est un moyen de connaitre le débit du consommateur 2 (quand ilprend du retard) ...
Ou mieux, sais-tu combien de temps chaque paquet reste dans la FIFO du consommateur?
As-tu une de ces informations ?

[pseudocode]

Voilà, j'espère que c'est plus clair !!!

Non.

C'était clair jusqu'a la phrase:

Je veux donc adapter la taille des paquets ( nbr d'échantillons ) qui sortent vers le consommateur 2 de façon à corriger le débit du consommateur 2.

Je ne comprend pas le rapport que tu fais entre "synchroniser" et "corriger le débit".

• Tu veux que les paquets en queue de fifo aient le meme timestamp ?
• Tu veux que les 2 consommateurs recoivent la meme quantité de données ?
• Autre ?

Si tu nous expliquais dans quel contexte tu as ce problème, ca serait peut-etre plus clair.

[Seb.26]

Non.

... c'est presque à la fin, c'est déjà pas mal !

Je ne comprend pas le rapport que tu fais entre "synchroniser" et "corriger le débit".

En fait, je veux que les données qui sortent de mes FIFOs vers les consommateurs restent synchronent : c-a-d que leur timestamp (enregistré lors de la réception, par rapport à l'horloge de mon PC) soient identiques ou alors très proche.

En fait, si je ne fais rien ( donc le PC agit juste comme une grosse FIFO ) le flux 2 se décale petit à petit, car le consommateur 2 consomme trop vite ou pas assez ... et arrive un moment, ou soit ma FIFO est vide ( = le consommateur 2 va trop vite ) ou alors que ma FIFO explose ( = le consommateur 2 va trop lentement )

Donc, la solution que je voudrais mettre en oeuvre, c'est de "corriger" le débit en amont du consommateur 2 en ajoutant ou en supprimant des échantillons de ses paquets.

Si tu nous expliquais dans quel contexte tu as ce problème, ca serait peut-etre plus clair.

Je suis pas sûr ...

En gros, les producteurs sont des systèmes embarqués qui échantillonnent en continu des données, ces données sont envoyées sous forme de groupe d'échantillons ( x échantillons sur x capteur ) ...
Producteur 1 = 5 capteurs, et 50000 éch/s (16b)
Producteur 2 = 1 canal, 100 ech/s ( lui réalise déjà pas mal de traitements en amonts via son dsp )

Les consommateurs sont eux aussi des systèmes embarqués, il signalent via une pin de sortie que leur FIFO est 1/2 vide, donc je dois envoyer de nouvelles données ( paquet d'échantillon )

Si le consommateur 1 est bien régulier, le 2 lui n'est pas très cool, pour pleins de raisons que je ne peux développer ici ( gros delta de température, état de batterie, type et nbr d'échantillons ... autres traitements en tache de fond )

Comme je ne peux pas agir sur la fréquence de consommation du 2 ( = son débit réel ) , je ne peux qu'agir sur le volume des infos que je lui envoie ...

Etant donné le volume et la nature des infos, il est acceptable de les dégrader légèrement par une interpolation ... c'est pour ça que je veux "resampler" ( on dit comme ça ? ) les données du flux 2.

[pseudocode]

un truc comme ca ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int delta = FIFO1.nexttimestamp - FIFO2.nexttimestamp;
int sample_gap = abs(delta)*debitconso1/debitconso2;
 
if (delta<0) {
 
  // supprimer "sample_gap" echantillons dans Fifo2
 
} else if (delta>0) {
 
  // ajouter "sample_gap" echantillons dans Fifo2
 
}

[Seb.26]

un truc comme ca ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int delta = FIFO1.nexttimestamp - FIFO2.nexttimestamp;
int sample_gap = abs(delta)*debitconso1/debitconso2;
 
if (delta<0) {
 
  // supprimer "sample_gap" echantillons dans Fifo2
 
} else if (delta>0) {
 
  // ajouter "sample_gap" echantillons dans Fifo2
 
}

Oui, ça ressemble fortement à ce que je voudrais obtenir ...

Mais ton algo va (je pense) générer des changements brusques, dans le sens ou "sample_gap" ne tient pas compte de l'historique, n'essaye pas de pré-corriger l'érreur ... d'ailleurs, je ne suis pas sûr que cela permette de rattraper un delta variable dans le temps ...

Donc, c'est ça, mais avec un coté un peu plus "asservissement intelligent" ...

Je regarde du coté des asservissement PID, mais j'arrive pas trop à mettre ça en application à mon cas ...
( http://ancrobot.free.fr/fichtech/action/pid/index.htm )

... Boulet que je suis !

En tout cas, merci du coup de main !

[pseudocode]

Utilise "sample_gap" comme valeur désirée en entrée de ta boucle d'asservissement, et utilise la valeur de consigne obtenue pour modifier Fifo2

[Seb.26]

C'est un moyen de connaitre le débit du consommateur 2 (quand ilprend du retard) ...
Ou mieux, sais-tu combien de temps chaque paquet reste dans la FIFO du consommateur?
As-tu une de ces informations ?

Désolé Graphito, j'avais zappé tes réponse/questions.

Merci à toi.

Alors, le temps dans les FIFO des consommateurs est peu important, mais je ne peux pas le connaitre ... ou alors je pourrais essayer de le determiner en mesurant le temps qui s"écoule entre chaque "demande" de données du consommateur ...

Mais en fait, si déjà le système sait s'adapter aux variations de débit du consommateur 2 en ajoutant / supprimant des échantillons dans les paquets, c'est gagné !

Au début, je pensais implémenter un truc très simple en prennant comme seule donnée, l'écart temporel des dernier timestamps des paquets envoyés ...

En gros, à chaque fois que j'envoie un paquet de x échantillons dans un des consommateur, je stocke le timestamp d'arrivé de ce paquet ( obtenu lors de la réception ) et je stocke aussi le timestamp réel "du quand" j'ai envoyé ce timestamp ...

Mais je sais pas quoi faire ensuite ...

[Seb.26]

Utilise "sample_gap" comme valeur désirée en entrée de ta boucle d'asservissement, et utilise la valeur de consigne obtenue pour modifier Fifo2

sample_gap est (comme son nom l'indique) le décalage (en nbr d'échantillons du flux2) qu'il y a entre les flux 1 et 2 ... c'est bien ça ?

c'est tout flou pour moi !!!

Bon, je vous laisse un peu tranquille, je vais potasser tout ça, et je reviens plus tard ...

[pseudocode]

sample_gap est (comme son nom l'indique) le décalage (en nbr d'échantillons du flux2) qu'il y a entre les flux 1 et 2 ... c'est bien ça ?

Bah je ne sais plus trop. Ma compréhension de ton problème change de post en post.

En ce moment j'en suis la:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
               timestamp   temps de ref = dernier envoi à C1
                  \/           \/
 
P1 (50000 éch/s) ---> [FIFO1] ---> C1 (50000 éch/s)
 
P2 (100 ech/s)   ---> [FIFO2] ---> C2 (~100 éch/s)

Auquel cas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
deltatemps = temps_de_ref - FIFO2.denier_timestamp_envoyé
 
if (deltatemps>0) {
  // C2 est en retard => il faut envoyer des paquets plus gros
  taille_paquet_ideale_pour_c2 = deltatemps * 100 / 50000
}
 
if (deltatemps<0) {
  // C2 est en avance => il faut envoyer des paquets plus petits
  taille_paquet_ideale_pour_c2 = 0
}
 
taille_paquet_actuelle_pour_c2 = Asservissement( taille_paquet_actuelle_pour_c2, taille_paquet_ideale_pour_c2)

[Seb.26]

Bah je ne sais plus trop. Ma compréhension de ton problème change de post en post.

Désolé !

Je suis vraiment pas clair on dirait !!!

Alors je vais essayer de mieux expliquer et de faire clair ! ... un p'tit dessin vous aidera à m'aider ...

[Seb.26]

Voilà ... alors, le système complet en gros, c'est ça :



Donc, le Flux 1 : qui va de P1 à C1 me sert d'horloge de référence, car il est figé dans le temps, et qu'il fonctionne bien comme ça.

J'ai donc régulierement une info venant de la FIFO 1 qui m'indique le Timestamp du paquet qui vient de quitter le PC (enregistrée à la réception), ainsi que le Timestamp du PC de l'instant ou le paquet est sorti.

Maintenant, le Flux 2 pose problème, car C2 ne va pas exactement à la même vitesse que P2.

Je veux donc modifier le volume des infos entre les 2 FIFO du flux 2 de façon à compenser l'écart de vitesse de C2.

Le tout devant s'adapter en temps réel en fonction de C2 ... et de façon "souple" ( pas d'escaliers, pas de variations brusques ... )

C'est pour cela que j'avais pensé à un asservissement PID, mais je n'arrive pas à passer de mon modèle à un algo ...

L'algo devant me donner un nombre 'x' ... 'x' étant le nombre d'échantillons à ajouter/supprimer du paquet du flux 2 lors de son passage entre les 2 FIFOS.
( pour que la latence soit minimale, en fait FIFO C2 ne peut contenir que 2 paquets, FIFO C2 pourrait n'être qu'un simple pointeur de paquet )

NB: l'objet que j'appelle paquet est en fait, un tableau de short ( les échantillons ) et le timestamp enregistré par le PC lors de la réception du paquet, les FIFOs contiennent des pointeurs vers ces paquets.

Voilà,
J'espère que c'est (cette fois ci) plus clair

Merci
Seb.

[pseudocode]

ah bah oui. c'est plus clair.

Question: il faut reguler par rapport a quoi ? les timestamps ? le volume d'echantillons ? autre ?

Si c'est les timestamp, il faut supprimer/creer des paquets dans le FIFO2 pour que le prochain paquet a envoyer a C2 ait le meme timestamp que le dernier paquet envoyé a C1 (+ le delai d'attente).

Si c'est le volume d'echantillons, il faut calculer le volume supplémentaire/maquant pour C2 et modifier la taille prochain paquet a envoyer a C2.

Dans tous les cas, il faut faire un asservissement pour eviter les sauts trop brusques.

[Seb.26]

ah bah oui. c'est plus clair.

Ouf !

Question: il faut reguler par rapport a quoi ? les timestamps ? le volume d'echantillons ? autre ?

Il faut réguler le nombre d'échantillons du flux 2 de façon à ce que les données sortent synchro les unes / autres.
Peut importe le retard dû aux FIFO, il faut juste que ce qui est entré en même temps ( flux 1 et flux 2 ) sorte en même temps.

Si c'est les timestamp, il faut supprimer/creer des paquets dans le FIFO2 pour que le prochain paquet a envoyer a C2 ait le meme timestamp que le dernier paquet envoyé a C1 (+ le delai d'attente).

Impossible : trop brutal

Si c'est le volume d'echantillons, il faut calculer le volume supplémentaire/maquant pour C2 et modifier la taille prochain paquet a envoyer a C2.

Voilà, c'est exactement ça !

Dans tous les cas, il faut faire un asservissement pour eviter les sauts trop brusques.

Oui, c'est là que je rame ...

Je pensais donc utiliser un asservissement type PID, avec comme facteur d'erreur le delta t des 2 sorties ( = timestamp du dernier paquet envoyé à chaque consommateur )

La réponse du PID devrait être le nombre d'échantillons à ajouter ( nombre positif ou négatif ) au prochain paquet qui sera envoyé au consommateur 2.

Une idée ?

[Seb.26]

PS: d'ailleurs, j'ai pensé à quelques résultats que l'on devrait obtenir pour 'x' ( la correction en nombre d'échantillons )

* si débit P1 = 50000 mais que débit C1 = 49500
-> x devra se stabiliser à -500

* si C1 monte ensuite à 51000
-> x devra dépasser un peu 51000 ( pour rattraper le retard accumulé )
-> puis, x se stabilisera à +1000

c'est exactement le fonctionnement d'un asservissement PID !



[Edit] En fait, ma consigne c'est 0 ( je ne veux aucun écart de temps ) ... mon facteur d'erreur, c'est le delta t ... et la sortie du filtre, c'est 'x' ...

[pseudocode]

Voilà, c'est exactement ça !

Dans l'idéal (brutal) la taille du prochain paquet a envoyer est soit:

* zéro, si C2 est en avance par rapport a C1
* retard_en_seconde*debit_P2, si C2 est en retard par rapport a C1

cette taille idéale est donc la valeur désirée (notée Ud dans ton schéma PID). La taille réelle sera la valeur de consigne (notée U dans ton schéma PID).