Simuler deux timers non synchronisés

Version imprimable

18/01/2011, 15h15
progfou

Simuler deux timers non synchronisés
Bonjour,

J'ai bien vu la FAQ python et la partie timer.
Autant, créer un timer ne me pose pas de problème, autant j'essaie de faire plus "subtil".
J'aimerais simuler un timer de la forme suivante :
Code:

1 2 3 4 |\ |\ |\ | \ | \ | \ | \| \| \
En gros, il décrémente une valeur régulièrement, jusqu'à atteindre 0, et à ce moment là, il repasse à sa valeur de période.

Mon soucis est aussi (surtout) d'en avoir deux, avec un décalage entre les deux (disons, le premier part et le second commence seulement 'offset' plus tard (ou inversement).

Alors, basiquement, je le ferai avec une boucle et un sleep entre chaque décrément.
Mais ça n'en simule pas deux...

Pouvez-vous m'aider ?
Merci d'avance !

Salut,

Une idée, comme ça, si Tkinter ne te rebute pas. Il y a sûrement moyen de factoriser les timers, c'est juste l'idée.

Code:

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
import Tkinter
 
T1_RELOAD_VALUE = 123
T1_PERIOD_VALUE = 10
T2_RELOAD_VALUE = 40
T2_PERIOD_VALUE = 60
 
def T1_interrupt():
    value = t1.get()
    if value == 0:
        t1.set(T1_RELOAD_VALUE)
    else:
        t1.set(value-1)
    root.after(T1_PERIOD_VALUE, T1_interrupt)
 
def T2_interrupt():
    value = t2.get()
    if value == 0:
        t2.set(T2_RELOAD_VALUE)
    else:
        t2.set(value-1)
    root.after(T2_PERIOD_VALUE, T2_interrupt)
 
root = Tkinter.Tk()
t1 = Tkinter.IntVar(value=T1_RELOAD_VALUE)
t2 = Tkinter.IntVar(value=T2_RELOAD_VALUE)
Tkinter.Label(root, textvariable=t1, width=20).grid()
Tkinter.Label(root, textvariable=t2, width=20).grid()
T1_interrupt()
T2_interrupt()
root.mainloop()

18/01/2011, 19h04
progfou

Je n'ai pas d'a priori ;).
Ca fait une partie de ce que je souhaite : deux timers qui décrémentent un compteur et reprennent à chaque fois.
Donc, en mettant les reload et period à des valeurs identiques pour les deux timers, j'ai l'équivalent de deux timers en phase.

Mais j'aimerais ajouter deux choses : un temps de décrément variable (genre, une seconde entre chaque décrément), et un offset entre les deux (l'un démarre N secondes avant l'autre).
Est-il possible de tracer les courbes correspondantes ?
Là, il y a un print, mais on peut sans doute faire un genre de "plot" ?

Eh eh, je m'auto-réponds, car je viens de comprendre...
La période est en msec.
Et je peux tout à fait faire :
Code:

1 2 3 4 5 6 7 8 root = Tkinter.Tk() t1 = Tkinter.IntVar(value=T1_RELOAD_VALUE) t2 = Tkinter.IntVar(value=T2_RELOAD_VALUE) Tkinter.Label(root, textvariable=t1, width=20).grid() Tkinter.Label(root, textvariable=t2, width=20).grid() root.after(0, T1_interrupt) root.after(1000, T2_interrupt) root.mainloop()
Pour décaler mes deux timers de 1 seconde l'un de l'autre.

Du coup, il reste principalement l'idée de tracer le graphique

19/01/2011, 08h30
pfeuh

Je te conseille matplotlib. La page "galerie" ci dessous est très bien, car elle te permet d'avoir d'un click le code correspondant au genre de tracé que tu cherches.
http://matplotlib.sourceforge.net/gallery.html
Les exemples donnés sont cependant statiques, il faudra pondre un peu de code pour avoir un plot dynamique.

Citation:

Donc, en mettant les reload et period à des valeurs identiques pour les deux timers, j'ai l'équivalent de deux timers en phase.

Je crois que tu cours vers une désillusion, car la méthode after est comme la fonction sleep, totalement dépendante de la plateforme et très imprécise. Tes timers seront très vite totalement désynchronisés. A mon sens, il faudrait un timer très rapide qui donnerait les ticks de base à tes deux timers.
19/01/2011, 09h03
progfou

L'idée n'est pas d'avoir deux timers ultra précis, mais de simuler la synchronisation de deux timers l'un par rapport à l'autre :).
Du coup, il est possible d'avoir une variable partagée par les deux threads (les deux interruptions) ? Histoire que quand elle passe à 1 dans une interruption, l'autre le sache par exemple ?
19/01/2011, 09h20
pfeuh

Citation:

Envoyé par progfou

Du coup, il est possible d'avoir une variable partagée par les deux threads (les deux interruptions) ? Histoire que quand elle passe à 1 dans une interruption, l'autre le sache par exemple ?

Oui, les variables t1 et t2 sont globales, donc accessibles en lecture/écriture par les 2 interruptions.
19/01/2011, 09h22
progfou

OK, reste à trouver comment utiliser matplotlib pour tracer la courbe voulue... :)
20/01/2011, 16h39
jack_x4

sinon tu peux utiliser a mon avis, 1 timer mais a une fréquence compatible au deux timer, avec des évènement déclenché en fonction des valeurs du timer.

Exemple : un timer 50 Htz et un timer 100 hert, deviens un seul et unique timer de 100 hertz avec un évènement tout les 100 htz / 2.

enfin en théorie !!!!