Discussion :

[jlg_47]

Bonjour,

Voilà le problème est simple.

J'ai un bout de programme qui fait une simulation temporelle du comportement d'un système.
Il y a donc une boucle dans le temps et un calcul qui s'exécute en fonction d'un pas de calcul :

Exemple :

Code :

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

1
2
3
4
5
6
7
8
temps = 0.
pas = 0.0001  # définition d'un pas de calcul de 0.0001 seconde

while (temps < 1000.):   #  durée de simulation de 1000 secondes
      #  là je voudrais récupéré la valeur d'une commande sans arrêter le calcul
      #  ici se situe le calcul
      temps = temps + pas

Je cherche la méthode la plus propre (et la plus simple) pour qu'à chaque pas de calcul mon programme puisse récupérer la valeur d'une commande sans s'arrêter évidemment.

J'ai fait une petite interface graphique avec Tkinter, un simple curseur qui me permet de régler ma commande.

Je voudrais maintenant que mon programme de simulation puisse récupérer la valeur du curseur au vol pendant qu'il continue à s'exécuter.

J'espère que c'est assez clair et que quelqu'un pourra m'aiguiller vers la solution idéale.

Bonne journée à tous et merci d'avance.

[PauseKawa]

Bonjour,

Regarde ici

@+

[airod]

regarde du coté de la fonction yield, elle est prévu pour ca!
http://blog.site2wouf.fr/2008/04/pyt...-de-yield.html

[jlg_47]

Bonjour,

Regarde ici

@+

Bonjour PauseKawa, bonjour Airod,


Bon, j'ai essayé ce que le lien de PauseKawa explique.

Cela marche mais j'ai un souci ... le programme se plante de façon aléatoire soit au bout de quelques secondes, soit au bout de quelques heures ... Mais toujours avec le même type d'erreur sans que ce soit exactement la même.

J'ai essayé d'isoler le problème et j'ai écrit un petit bout qui gère une fenêtre de ce type :



Le programme est constitué :

1- du main qui gère la fenêtre
2- un thread qui exécute la simulation
3- un autre thread qui écrit dans les afficheurs à gauche le temps et une variable (rpm comme Rotation Par Minute; il s'agit de la vitesse d'un ventilateur)

Quand on bouge le curseur, le rpm va rejoindre la vitesse demandée avec une accélération d'un tour par seconde, c'est le thread de simulation qui calcule cette valeur ... Donc au bout de quelques secondes la valeur affichée devient égale à celle demandée comme c'est le cas sur l'image.

Maintenant voici le genre d'erreur que je récupère :



C'est toujours dans le thread d'affichage que ça plante.
Certaines fois Python va jusqu'à dire qu'il ne connaît pas la méthode "configure"

Y a t-il une manière plus propre pour faire cela?

Voici le bout de code correspondant:

Code :

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

1
2
3
4
5
def Afficher():
    while (simul_terminated == 0):              
        label_temps.configure(font = ("Arial",15),text =("%7.0f  s" %temps))
        label_rpm.configure(font = ("Arial",15),text =("%7.2f" %fan_rpm))
        time.sleep (.5)

Merci d'avance pour votre aide.

Bonne journée

PS :

Pendant que j'écrivais mon post, le prog tournait, il vient de se planter après 2239 secondes de simulation soit après être passé près de 5000 fois sans problème à l'endroit litigieux

Voici le message cette fois ci:

[PauseKawa]

Bonjour,

1- du main qui gère la fenêtre
2- un thread qui exécute la simulation
3- un autre thread qui écrit dans les afficheurs à gauche le temps et une variable (rpm comme Rotation Par Minute; il s'agit de la vitesse d'un ventilateur)

Pourquoi deux thread ?

@+

[PauseKawa]

Re jlg_47,

L'idée de base c'est d'utiliser les classes variable de tkinter mais surtout le .trace.

Code :

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

1
2
3
4
5
6
def callback(*args):
    print "variable changed!"
 
var = StringVar()
var.trace("w", callback)
var.set("hello")

Dans ce cas je ne comprend pas tes deux threads.

Il me semble que tu as ta fenêtre tk puis ton thread qui tourne et enfin un thread pour vérifier le premier... Inutile donc ? Sans doute.

Plus de code ?

@+

[jlg_47]

Bonjour,



Pourquoi deux thread ?

@+

Merci PauseKawa,

C'est la question que je me pose depuis hier soir

Tu as sûrement raison, le second thread est inutile ...
Mais je me dis que cela devrait quand même fonctionner même si on peut faire plus simple.

Je débute et Tkinter est encore obscure pour moi ...
J'ai adopté cette solution parce que je ne voyais pas bien comment rafraichir les afficheurs, je ne connaissais pas .trace

Je vais essayer ce que tu proposes.

[josmiley]

aléatoir ...
ça ressemble à un probleme de verrou ...

[jlg_47]

aléatoir ...
ça ressemble à un probleme de verrou ...

Normalement il n'y a pas besoin de verrou puisqu'un seul thread modifie la variable, l'autre ne faisant que l'afficher.
J'y ai pensé à un moment et j'ai mis un verrou; mais le problème est toujours là et toujours de façon aléatoire.

Merci pour l'aide

Bonne journée

[jlg_47]

L'idée de base c'est d'utiliser les classes variable de tkinter mais surtout le .trace.

Code :

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

1
2
3
4
5
6
def callback(*args):
    print "variable changed!"
 
var = StringVar()
var.trace("w", callback)
var.set("hello")

Bonjour PauseKawa,

Merci beaucoup,
Mais je ne comprends pas du tout comment utiliser cette classe ... je suis nul en prog objet

J'ai fait un petit bout de code, je voudrais afficher dans le label de la fenêtre la variable temps qui est calculée dans le thread

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
33
34
35
36
37
38
39
40
41
42
43
from Tkinter import *
import threading
import time

from sys import modules
progmain = modules['__main__']

global calcul_running , temps   #  le temps est calculé par le 
thread et affiché dans la fenêtre

def thread1():
    progmain.temps = 0.
    while 1:
            progmain.temps = progmain.temps +1. # incrémentation du temps
            time.sleep (1.)
       
def start_thread():
    progmain.calcul_running = 0
    t1=threading.Thread(target=thread1)
    t1.start()

def stop_thread():
    progmain.calcul_running = 1

#    debut du prog

root = Tk()

temps=0.
# label d'affichage du temps .... 
c'est sûrement là qu'il faut rajouter des choses
afficheur = Label(root, font = ("Arial",15),text = temps)
afficheur.pack()
# l'objectif est que l'afficheur soit mis à jour 
quand le thread incrémente le temps

Bouton_start=Button(root,text='Démarrer le calcul',command=start_thread)
Bouton_start.pack()

Bouton_stop=Button(root,text='Arrêter le calcul',command=stop_thread)
Bouton_stop.pack()

root.mainloop()

Le thread de calcul ne fait qu'incrémenter la variable

Code :

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

temps

Je pense qu'il faut mettre quelque part des trucs du genre :

Code :

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

temps = DoubleVar()

et

Code :

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

temps.trace("w", ....)

et

Code :

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

temps.set(...)

Le but est que l'afficheur incrémente le temps au fur et à mesure que le thread le recalcule ...

Merci encore pour l'aide

Bonne journée

[PauseKawa]

Bonjour,

Sans trop toucher à ton code.

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
#!/usr/bin/env python
# -*- coding: ISO8859-1 -*-
#
#
from Tkinter import *
import threading
import time
 
from sys import modules
progmain = modules['__main__']
 
global calcul_running
 
def thread1():
    temps.set(0.)
    while calcul_running==0:
        temps.set(temps.get() + 1.)
        time.sleep (1.)
 
def start_thread():
    global calcul_running
    calcul_running = 0
    t1=threading.Thread(target=thread1)
    t1.start()
 
def stop_thread():
    global calcul_running
    calcul_running = 1
 
def tempscb(varName, index, mode):
    afficheur.config(text=str(temps.get()))
 
#    debut du prog
 
root = Tk()
 
afficheur = Label(root, font=("Arial",15))
afficheur.pack()
temps=DoubleVar()
temps.trace_variable("w", tempscb)
temps.set(0.)
 
Button(root,text="Démarrer le calcul", command=start_thread).pack()
Button(root,text="Arrêter le calcul", command=stop_thread).pack()
 
root.mainloop()

Par contre les globals... Pas bien

@+

[jlg_47]

Merci, PauseKawa

incroyable ! même le dimanche tu es présent pour aider
Formidable ce forum ..

Ici il est bientôt 19 heures, je rejoins des amis au resto et je m'y remets en rentrant
Cela buggue, mais je devrais peut-être trouver pourquoi je reçois ces 2 messages :





Pour les globals, je verrai cela après ... je sais que ce n'est pas bô

Bonne journée et merci encore

[PauseKawa]

Bonjour,

Je viens de comprendre l'allusion de ma femme sur le repos dominical...

Ceci dit, et puisque je ne veux pas troubler ta digestion , la réflexion attendue pour les globals étais : Mais il existe une variable booléenne en tk.

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
33
34
35
36
37
38
39
40
#!/usr/bin/env python
# -*- coding: ISO8859-1 -*-
#
#
from Tkinter import *
import threading
import time
 
def thread1():
    temps.set(0.)
    while calcul_running.get()==False:
        temps.set(temps.get() + 1.)
        time.sleep (1.)
 
def start_thread():
    calcul_running.set(False)
    t1=threading.Thread(target=thread1)
    t1.start()
 
def stop_thread():
    calcul_running.set(True)
 
def tempscb(varName, index, mode):
    afficheur.config(text=str(temps.get()))
 
root = Tk()
 
afficheur = Label(root, font=("Arial",15))
afficheur.pack()
 
temps=DoubleVar()
temps.trace_variable("w", tempscb)
temps.set(0.)
 
calcul_running=BooleanVar()
 
Button(root,text="Démarrer le calcul", command=start_thread).pack()
Button(root,text="Arrêter le calcul", command=stop_thread).pack()
 
root.mainloop()

Pour ce qui est de tes messages d'erreur je n'ai pas trop l'habitude de Python sous Windows mais je pense plus à une fermeture du programme (principalement de ta fenêtre Tk) avant les threads.
Il existe un sujet en cours sur le forum.

@+ et bon app

[jlg_47]

Merci PauseKawa,


Je suis rentré ...

Je regarde cela de près ...

J'ai réduit le prog au strict minimum et cela marche nickel

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
#!/usr/bin/env python
# -*- coding: ISO8859-1 -*-
#
#
from Tkinter import *
import threading
import time
 
def thread1():
    temps.set(0.)
    while 1:
        temps.set(temps.get() + 1.)
        time.sleep (1.)
 
def tempscb(varName, index, mode):
    afficheur.config(text=str(temps.get()))
 
#    debut du prog
 
root = Tk()
 
afficheur = Label(root, font=("Arial",15))
afficheur.pack()
temps=DoubleVar()
temps.trace_variable("w", tempscb)
temps.set(0.)
 
t1=threading.Thread(target=thread1)
t1.start() 
 
root.mainloop()

Merci encore et bon dimanche

[josmiley]

donne le code qui calcule temps ...

[jlg_47]

donne le code qui calcule temps ...

Bonjour josmiley;

Mon prog fait de la simulation;
Lors d'un pas de calcul, on calcule essentiellement la dérivée temporelle des variables ...
Ensuite à moi d'évaluer pendant combien de temps cette dérivée à un sens physique .. ce temps me fixe la durée réelle du pas ...

Donc le calcul du temps, c'est

Code :

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

temps = temps + pas

Pour avoir des résultats qui collent avec le processus physique, dans la majorité des cas, pas varie entre 1 milliseconde et 1 microseconde.

Bonne journée

[jlg_47]

Bonjour PauseKawa,

Je tiens encore à te remercier et te dire que cela fonctionne nickel

En ce moment, je galère un peu pour essayer de faire la même chose mais en affichant des petits graphiques ...
Je voudrais en effet suivre certains paramètres en visualisant leur variation sous forme d'un petit graphique en plus des chiffres.

Dans le thread de calcul, ces variables sont souvent dans des tableaux numpy.

J'ai principalement 2 tableaux de n (10<n<50) valeurs chacun que je voudrais visualiser sous forme de barographes mis à jour toutes les 1 à 2 secondes de simulation.
Et une autre variable que je voudrais suivre un peu comme la trace d'un oscilloscope très basse fréquence.

As tu une suggestion?

Pour garder tout dans la même fenêtre, j'ai bidouillé avec "create_line" de Tkinter, mais c'est fastidieux et cela fonctionne mal (le prog se plante de façon aléatoire)

J'ai regardé matplotlib ... mais je vois mal comment garder ma fenêtre Tkinter et ouvrir des fenêtres supplémentaires matplotlib qui se réactualisent ...

De plus, mon souhait est que mon thread de calcul reste aussi indépendant que possible de l'IHM ... Il fonctionne bien sur le plan mathématique, il est validé; donc je voudrais le tripoter le moins possible !

Bonne journée

[PauseKawa]

Bonjour,

Pour ce qui est de numpy et matplotlib je ne vais pas pouvoir t'aider car je ne les utilisent pas. Tu trouveras sans doute des exemples sur le forum.

Par contre pour ce qui est d'un canvas pas de problème. Montre ton code qui coince.

@+

[jlg_47]

Merci PauseKawa,

Voilà ce que j'ai écrit, je pense que c'est bourré de choses inutiles :

Dès que j'ai 10 minutes, je ferai un petit bout simple sans la recherche de mise à l'échelle ...
Je ne suis pas encore familiarisé avec la prog objet et je ne sais pas trop quand mettre des "self."

CE bout de code fonctionne ... mais s'il est appelé cycliquement ... il plante à un moment ou un autre

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
# -*- coding: cp1252 -*-
 
from Tkinter import *
import numpy as np
 
class Graph(Frame):
    """Barographes"""
    def __init__(self, maitre=None, hauteur=100, largeur = 200, fond = 'white', dimension=20):
        Frame.__init__(self)        # constructeur de la classe parente
 
        # Définition des attributs d'instance :
 
        self.hauteur = hauteur
        self.largeur = largeur
        self.fond = fond
        self.dimension = dimension
        self.tab_old = np.zeros(shape =(self.dimension),dtype=np.float)
 
 
        # Définition du widget graph :
        self.gr = Canvas (self,height = self.hauteur, width = self.largeur, bg = fond)
        self.gr.pack()
 
 
        # fonction de tracé
    def setTrace(self, tab, scale):
        x=range(self.dimension)
        y=range(self.dimension)
        y_old=range(self.dimension)
 
        x[0] = 0.
        y_max = np.max (tab)
        y_min = np.min (tab)
        y_old_max = np.max (self.tab_old)
        y_old_min = np.min (self.tab_old)
        y_mean = int ((y_max + y_min)/2. + .5)
        y_old_mean = int ((y_old_max + y_old_min)/2. + .5)
 
        y[0] = scale * (y_mean - tab [0] ) + self.hauteur/2
        y_old[0] = scale * (y_old_mean - self.tab_old [0] ) + self.hauteur/2
 
        pas = float (self.largeur / self.dimension)
        i = 1
        while (i < self.dimension):
            x[i] = float (pas * i)
            y[i] = scale * (y_mean - tab [i] ) + self.hauteur/2
            y_old[i] = scale * (y_old_mean - self.tab_old [i]) + self.hauteur/2
            self.gr.create_line(x[i-1],y_old[i-1],x[i],y_old[i],fill=self.fond)
            self.gr.create_line(x[i-1],y[i-1],x[i],y[i])
            i = i+1
        self.gr.create_line(x[self.dimension-1],y_old[self.dimension-1],self.largeur,y_old[0],fill=self.fond)
        self.gr.create_line(x[self.dimension-1],y[self.dimension-1],self.largeur,y[0])
        self.tab_old = np.copy(tab)
 
 
#### Code pour tester la classe : ###
 
if __name__ == '__main__':
 
    n = 20
    temp = np.ndarray(shape =(20),dtype=np.float)
    temp.fill (120.)
 
 
    root = Tk()
    gra = Graph(root,200,400,'cyan')
    gra.pack(side =TOP)
 
    gra.setTrace (temp, 10.)
    i = 0
    while (i<n):
        temp [i] = 120. + .5*(i-5.)
        if (i > 12): temp[i] = temp[i] +2.
        i=i+1
    gra.setTrace (temp, 10.)
    root.mainloop()

[PauseKawa]

Bonjour,

Vu, mais pas le temps cet aprem.
Je regarde cela ce soir promis.

@+