Modification d'une variable dans un programme pendant son exécution

Version imprimable

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:

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.

07/04/2010, 15h07
PauseKawa

Bonjour,

Regarde ici

@+
07/04/2010, 22h25
airod

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

Citation:

Envoyé par PauseKawa

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.:mrgreen:

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

http://i63.servimg.com/u/f63/11/33/10/05/fenetr10.jpg

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 :

http://i63.servimg.com/u/f63/11/33/10/05/erreur10.jpg

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:

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 :mrgreen:

Voici le message cette fois ci:

http://i63.servimg.com/u/f63/11/33/10/05/erreur11.jpg

09/04/2010, 19h08
PauseKawa

Bonjour,

Citation:

Envoyé par jlg_47

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 ?

@+
09/04/2010, 20h48
PauseKawa
Re jlg_47,

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

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 ?

@+
10/04/2010, 07h05
jlg_47

Citation:

Envoyé par PauseKawa

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.
10/04/2010, 10h56
josmiley

aléatoir ...
ça ressemble à un probleme de verrou ...
11/04/2010, 10h40
jlg_47

Citation:

Envoyé par josmiley

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

Citation:
Envoyé par PauseKawa
L'idée de base c'est d'utiliser les classes variable de tkinter mais surtout le .trace.
Code:

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 :aie:

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:

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:

temps

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

Code:

temps = DoubleVar()

et

Code:

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

et

Code:

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

Bonjour,

Sans trop toucher à ton code.

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

@+

11/04/2010, 13h25
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 :

http://i63.servimg.com/u/f63/11/33/10/05/python10.jpg

http://i63.servimg.com/u/f63/11/33/10/05/python11.jpg

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

Bonne journée et merci encore

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 :roll:, la réflexion attendue pour les globals étais : Mais il existe une variable booléenne en tk.
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 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

Merci PauseKawa,

Je suis rentré ...

Je regarde cela de près ...

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

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
#!/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

13/04/2010, 12h37
josmiley

donne le code qui calcule temps ...
22/04/2010, 07h37
jlg_47

Citation:

Envoyé par josmiley

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:

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
22/04/2010, 08h01
jlg_47

Bonjour PauseKawa,

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

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:aie:)

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 8-)
22/04/2010, 09h00
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.

@+

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." :mrgreen:

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

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

22/04/2010, 15h02
PauseKawa

Bonjour,

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

@+
23/04/2010, 01h35
jlg_47

Citation:

Envoyé par PauseKawa

Bonjour,

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

@+

Merci, apparemment tu n'as pas trouvé le temps.

Moi non plus, il faudrait d'abord que je retire tout ce qui n'est pas primordial.

A bientot.

JL

Bonjour,

C'est sur qu'avec ta boucle while avant le mainloop ton canvas ne s'affiche qu'à la fin.

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
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
77
78
79
80
81
# -*- 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 +=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 : ###
def lancetrace():
    i = 0
    while (i<n):
        temp [i] = 120. + .5*(i-5.)
        if (i > 12): temp[i] += 2.
        gra.setTrace (temp, 10.)
        i+=1
 
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)
 
    Button(root, text="start", command=lancetrace).pack()
 
    #gra.setTrace (temp, 10.)
 
    #gra.setTrace (temp, 10.)
    root.mainloop()

C'est ta courbe finale ou tu as besoin d'un scrolling ?

@+

Edit : Je présume que le while est là pour simuler le calcul ?

23/04/2010, 11h21
jlg_47

Bonjour PauseKawa,

J'ai un tableau de n valeurs physiques qui évoluent dans le temps.
En fait c'est une distribution de température le long d'un tuyau ... Donc les n valeurs sont prises à différentes abscisses le long du tuyau.

Et je veux à chaque seconde, tracer la distribution de températures sur un barographe ..

Donc toutes les valeurs sont à prises au même instant ..
La boucle while est pour aller d'une abscisse à l'abscisse suivante.

les grandeurs sont mémorisées dans tab_old uniquement pour effacer la courbe précédente en retraçant la courbe avec la couleur de fond, il y a peut-être une solution plus astucieuse ... mais je n'ai rien trouvé du genre Canvas.clear ...

Bonne journée
23/04/2010, 11h58
PauseKawa

Bonjour,

self.gr.delete(tab ou id) ou self.gr.delete(ALL)

@+

Citation:

Envoyé par PauseKawa

Bonjour,

self.gr.delete(tab ou id) ou self.gr.delete(ALL)

@+

Merci une fois de plus PauseKawa,

Cela simplifie déjà bien le code et c'est surement plus rapide ...

Par contre ça plante toujours de façon aléatoire :cry:

Je me demande si passer un array Numpy (tab) est acceptable ..

Voici le code dépoussiéré :

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
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
# -*- 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               
 
        # 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):
#  tab est un array numpy ... est ce bien permis ??????
        x=range(self.dimension)
        y=range(self.dimension)
 
        x[0] = 0.
        # calage des données entre min et max
        y_max = np.max (tab)
        y_min = np.min (tab)
        y_mean = int ((y_max + y_min)/2. + .5)
        
        
    
        pas = float (self.largeur / self.dimension)
        self.gr.delete (ALL)  # destruction du tracé précédent
        y[0] = scale * (y_mean - tab [0] ) + self.hauteur/2
        i = 1
        while (i < self.dimension):
            x[i] = float (pas * i)
            y[i] = scale * (y_mean - tab [i] ) + self.hauteur/2
            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[self.dimension-1],self.largeur,y[0])

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

Merci encore et bonne journée

Bonjour,

Je ne comprend pas tes calculs (désolé), pour moi ton code fonctionne.

Du moins sous cette forme

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
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
# -*- 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               
        # Définition du widget graph :
        conteneur=Frame(self)
        conteneur.pack(side=TOP)
        self.yscrollbar = Scrollbar(conteneur)
        self.xscrollbar = Scrollbar(self, orient=HORIZONTAL)
        self.gr=Canvas(conteneur, height=self.hauteur, width=self.largeur, bg=self.fond, xscrollcommand=self.xscrollbar.set, yscrollcommand=self.yscrollbar.set)
        self.gr.pack(side=LEFT)
        self.yscrollbar.pack(side=RIGHT, fill=BOTH)
        self.yscrollbar.config(command=self.gr.yview)
        self.xscrollbar.pack(fill=BOTH)
        self.xscrollbar.config(command=self.gr.xview)
 
        # fonction de tracé
    def setTrace(self, tab, scale):
        x=range(self.dimension)
        y=range(self.dimension)
        x[0]=0.
        # calage des données entre min et max
        y_max=np.max (tab)
        y_min=np.min (tab)
        y_mean=int((y_max+y_min)/2.+.5)
        pas=float(self.largeur/self.dimension)
        self.gr.delete(ALL)  # destruction du tracé précédent
        y[0]=scale*(y_mean-tab[0])+self.hauteur/2
        i=1
        while (i<self.dimension):
            x[i]=float(pas*i)
            y[i]=scale*(y_mean-tab[i])+self.hauteur/2
            self.gr.create_line(x[i-1], y[i-1], x[i], y[i])
            self.gr.update()
            i+=1
        #self.gr.create_line(x[self.dimension-1], y[self.dimension-1], self.largeur, y[0])
 
#### Code pour tester la classe : ###
def lancetrace():
    i=0
    while (i<n):
        print i
        temp[i]=120.+.5*(i-5.)
        if (i>12):
            temp[i]+=2.
        gra.setTrace(temp, 10.)
        i+=1
 
if __name__ == '__main__':
    n=100
    temp=np.ndarray(shape=(n), dtype=np.float)
    temp.fill(120.)
    root=Tk()
    gra=Graph(root, 600, 800, 'cyan', n)
    gra.pack(side=TOP)
    Button(root, text="start", command=lancetrace).pack()
    root.mainloop()

Le message d'erreur est ?

@+

23/04/2010, 18h00
jlg_47

Merci, je regarde cela ....

Le message d'erreur n'est pas toujours le même ....

Il y a trois possibilités :

- 1ier cas : le programme se termine tout seul sans message d'erreur, sans rien simplement comme si je l'avais arrêté moi même ... et si je retire les barographes cela ne se produit jamais ... j'en conclus donc que le problème est là ...

- second cas : je reçois un message du genre : "la mémoire @%xxxxx ne peut pas être read Python.exe doit être interrompu OK "

- 3ième cas : "erreur dans xxxx.setTrace ....." qui laisse sous entendre un débordement de tableau ... si c'est le cas cela devrait être systématique puisque 10000 fois par seconde le programme fait exactement la même chose

Et si je retire les barographes ... tout fonctionne nickel pendant des heures, une nuit entière sans crash :lol:

Avec les barographes, ça peut tourner 1 heure, mais ça peut aussi planter au bout de 10 secondes, ou 10 minutes ...

Je pense qu'il y a quelque part un truc qui déborde ... s'il déborde dans une zone non critique ça passe sans problème ... sinon ça buggue ..

Je regarde ton bout de code et je te tiens informé.

Merci encore
Je vais dormir, il est presque minuit ..

A+
23/04/2010, 18h13
jlg_47

Re ..

Je ne suis pas encore couché.

J'ai fait tourner plusieurs fois le bout de code que tu as corrigé.
Il a fonctionné parfaitement une trentaine de fois
Et plouf un coup sans savoir pourquoi, il m'a balancé un message d'erreurs similaire à ce que je reçois de façon aléatoire :aie:

http://i63.servimg.com/u/f63/11/33/10/05/ecran10.jpg

:cry::cry::cry::cry:

A+

Bonsoir,

Bizarre, on dirais qu'il garde le nom mais perd l'objet... Et encore même pas puisqu'il utilise Tcl. C'est plutôt le type du widget qui est perdu (utilisation du nom pour autre chose ou fatigue mentale de ma part ?).

Dans ce cas autant réduire pour voir ou/si cela bloque

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# -*- coding: cp1252 -*-
 
from Tkinter import *
import numpy as np
 
        # fonction de tracé
def setTrace(tab, scale):
    x=range(100)
    y=range(100)
    x[0]=0.
    # calage des données entre min et max
    y_max=np.max (tab)
    y_min=np.min (tab)
    y_mean=int((y_max+y_min)/2.+.5)
    pas=float(200/100)
    gr.delete(ALL)  # destruction du tracé précédent
    y[0]=scale*(y_mean-tab[0])+100/2
    i=1
    while (i<100):
        x[i]=float(pas*i)
        y[i]=scale*(y_mean-tab[i])+100/2
        gr.create_line(x[i-1], y[i-1], x[i], y[i])
        gr.update()
        i+=1
    #self.gr.create_line(x[self.dimension-1], y[self.dimension-1], self.largeur, y[0])
 
#### Code pour tester la classe : ###
def lancetrace():
    i=0
    while (i<n):
        print i
        temp[i]=120.+.5*(i-5.)
        if (i>12):
            temp[i]+=2.
            setTrace(temp, 10.)
        i+=1
 
if __name__ == '__main__':
    n=100
    temp=np.ndarray(shape=(n), dtype=np.float)
    temp.fill(120.)
    root=Tk()
    conteneur=Frame(root)
    conteneur.pack(side=TOP)
    yscrollbar = Scrollbar(conteneur)
    xscrollbar = Scrollbar(root, orient=HORIZONTAL)
    gr=Canvas(conteneur, height=600, width=800, bg='cyan', xscrollcommand=xscrollbar.set, yscrollcommand=yscrollbar.set)
    gr.pack(side=LEFT)
    yscrollbar.pack(side=RIGHT, fill=BOTH)
    yscrollbar.config(command=gr.yview)
    xscrollbar.pack(fill=BOTH)
    xscrollbar.config(command=gr.xview)
    Button(root, text="start", command=lancetrace).pack()
    root.mainloop()

Et encore... Tu peut mettre setTrace dans lancetrace.

@+

Edit : Tu devrais refaire un sujet. Cela ne correspond plus au titre et tu aurais plus de chance d'avoir une réponse.

24/04/2010, 06h47
PauseKawa

Bonjour,

Il est aussi possible que cela soit le type float de ta liste.
Donc gr.create_line(int(x[i-1]), int(y[i-1]), int(x[i]), int(y[i]))

Les valeurs ? Tu semble avoir une plage grosso modo de -350/+350 pour x/y (principalement y).
Il serait peut etre bon de faire une marge de 400, faire un canvas de 800 et de faire y[i]+400 (donc 400=0). De même pour x.

Enfin, cela iras mieux après le café.

@+

Edit : Fais aussi un print x[i-1], y[i-1], x[i], y[i] avant ton create_line pour vérifier tes données.
Pour l'histoire du 400 c'est juste pour l'affichage. J'ai fais
print x[i-1], y[i-1], x[i], y[i]
#print type(x[i])
gr.create_line(int(x[i-1]), int(y[i-1])+400, int(x[i]), int(y[i])+400)

@++
24/04/2010, 09h07
jlg_47

Merci encore PauseKawa de t'intéresser à mon cas ..

Effectivement en repassant en pixels, je me retrouve avec des entiers, je n'y avais pas pensé ....

Les valeurs sont bonnes car le programme de simulation fonctionne nickel sans les barographes .... et si par malheur une variable était erronée il se planterait immédiatement ...

J'ai refait un bout de code minimum ... avec la génération de la fenêtre ... un thread minimum qui calcule une distribution de température fictive ... et toujours le même pb évidemment :mouarf:

Je regarde en passant en entiers et en vérifiant bien les valeurs limites ...

Sinon je suivrai ton conseil en ouvrant un autre fil ...

Bonne journée
24/04/2010, 17h20
jlg_47

Bonjour PauseKawa,

Je ne crie pas victoire ...
Mais depuis le passage des coordonnées en entiers dans les appels à create_line je n'ai pas noté de plantage ..

Bonne journée et merci encore
24/04/2010, 19h05
PauseKawa

Bonjour,

Une bonne chose pour moi : J'étais en train de revoir cela avec pylab (que je ne connais pas) pour te trouver une soluce.
Je suis donc en Weekend :mouarf:

@+
28/04/2010, 04h44
jlg_47

Citation:

Envoyé par PauseKawa

Bonjour,

Une bonne chose pour moi : J'étais en train de revoir cela avec pylab (que je ne connais pas) pour te trouver une soluce.
Je suis donc en Weekend :mouarf:

@+

Bonjour PauseKawa,

J'avais raison de ne pas crier victoire ...

Il y a encore des plantages, mais très rarement, avec le message:

L'instruction à "0x00db5d23" emploie l'adresse mémoire "0x0000000c" la mémoire ne peut pas être "read" ...

J'imprime les données mais rien d'anormal et Python n'envoie aucun message ..

Le pb est que c'est très rare, il faudrait que je fasse tourner le prog sans les graphes, car le problème est peut-être ailleurs ..
Je ne suis pas très bon en prog objet, je fais beaucoup de chose à tâtons :aie:

Bonne journée

Fuseau horaire GMT +2. Il est actuellement 15h12.