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

Version imprimable

Voir 40 message(s) de cette discussion en une page

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

Voir 40 message(s) de cette discussion en une page