Discussion :

[progfou]

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 :

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

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 !

[pfeuh]

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 :

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
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()

[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" ?

[progfou]

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 :

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

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

[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.

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.

[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 ?

[pfeuh]

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.

[progfou]

OK, reste à trouver comment utiliser matplotlib pour tracer la courbe voulue...

[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 !!!!