Intervallom�tre sous python

**Fred973** · 15/09/2020, 17h38

Bonjour tout le monde,

Voila quelques jours que je bloque sur une solution � mon probl�me. J'essaie de faire un petit logiciel de contr�le d'appareil photo Canon. pour cela j'ai bien sur une interface s�rie (Arduino) ou plus tard pyserial. Bref, le probl�me n'est pas l� ceci fonctionne � merveille.
Dans mon logiciel j'ai deux modes de prise de photo (les astrophotographes reconna�tront l'utilit� de ce programme ...

) :

- Intervallom�tre classique : temps de pose, temps entre les poses et le nombre de pose.
- Mis au point : qui consiste � prendre une seule photo rapide afin d'effectuer la mise au point.

Mon module de mise au point fonctionne nickel, je peux passer l'�tat des widjets en DISABLED durant la pose et afficher le temps restant ainsi que le mode utilis�.
Voila ou �a se complique...
Pour faire mon intervallom�tre j'aimerai pouvoir afficher le nombre de photo restant et le temps total restant de toute les prises, cependant il est tr�s difficile, avec mes petites comp�tences, de le faire. J'ai tout de m�me r�ussi � le faire mais d'une mani�re diff�rente que le mode mise au point qui m'emp�che de prendre la main sur les widgets. Je sais qu'il est impossible de commander des widgets quand une boucle de la lib "time" comme "sleep" est utilis�e, car celle-ci est bloquante dans un environnement tkinter qui est , si j'ai bien compris, une boucle en elle-m�me.

Donc me voila dans un dilem j'ai essay� plusieurs chose mais �a "bloque" � chaque fois .... bref quelqu'un pourrait m�aiguiller sur la mani�re de faire pour avoir une solution qui pourrait d�compter (photo restantes � prendre) des boucles (temps d'exposition et temps entre pose) dans un environnement tkinter afin de pouvoir garder le contr�le sur l'affichage des labels et l��tat des widgets(combobox, button, etc...).
Je vous mets le code complet en esp�rant qu'ils soient assez clair :
Merci d'avance pour votre aide.
Fred

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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
from tkinter import *
from tkinter import messagebox, ttk
from time import sleep
 
"""upload StandardFirmata.ino"""
import pyfirmata
 
counter_id = None
counter_time_between_id = None
exposure_time = [1, 2, 3, 4, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90]
 
"""connection à la carte Arduino"""
# pin = 10
# strComPort = '/dev/ttyACM0'
# strComBaud = 9600
# brdUno = pyfirmata.Arduino(strComPort)
 
 
def intervalometer(c, texp, tbet):
    for i in range(c):
        if i != 0:
            c = c - 1
            print("reste :", c, "photos.")
 
            """Envoi signal externe on"""
            # brdUno.digital[pin].write(1)
            print("Photo en pose On")
            sleep(texp)
            """Envoi signal externe off"""
            # brdUno.digital[pin].write(0)
            print("Photo en pose Off")
 
            print("temps entre la pose")
            sleep(tbet)
    return c
 
 
def run_intervalometer():
    c = int(nbr_picture_entry.get()) + 1
    texp = int(exposure_intervalometer_value_combobox.get())
    tbet = int(time_between_combobox.get())
    intervalometer(c, texp, tbet)
 
 
def run_map():
    mode_value['text'] = "Mise au point"
    remain_pic_label['state'] = DISABLED
    button_stop['state'] = NORMAL
    t = int(exposure_intervalometer_value_combobox_map.get())
    run(t)
 
 
def run(t):
    expo_time_map(t)
    """Envoi signal externe on"""
    # brdUno.digital[pin].write(1)
 
 
def expo_time_map(exp_time_map):
    """blocage des widgets durant la photo"""
    # Mise au point
    button_run_map['state'] = DISABLED
    exposure_intervalometer_value_combobox_map['state'] = DISABLED
 
    # Intervalomètre
    button_run_intervalometer['state'] = DISABLED
    exposure_intervalometer_value_combobox['state'] = DISABLED
    time_between_combobox['state'] = DISABLED
    nbr_picture_entry['state'] = DISABLED
 
    global counter_id
 
    """convertisseur seconde en h:m:s"""
    days = divmod(exp_time_map, 86400)
    hours = divmod(days[1], 3600)
    minutes = divmod(hours[1], 60)
    remain_time_value['text'] = "%i h %i min %i sec." % (hours[0], minutes[0], minutes[1])
 
    if exp_time_map > 0:
        counter_id = root.after(1000, expo_time_map, exp_time_map - 1)
    else:
        fin()
 
 
def fin():
    if counter_id:
        root.after_cancel(counter_id)
        remain_time_value['text'] = "Terminé"
 
        """Envoi signal externe off"""
        # brdUno.digital[pin].write(0)
 
        messagebox.showinfo("", "Prise terminée !")
        """Déblocage des widgets une fois la ou les photo(s) terminée(s)"""
 
    # Mise au point
    button_run_map['state'] = NORMAL
    exposure_intervalometer_value_combobox_map['state'] = NORMAL
    button_stop['state'] = DISABLED
 
    # Intervalomètre
    button_run_intervalometer['state'] = NORMAL
    exposure_intervalometer_value_combobox['state'] = NORMAL
    time_between_combobox['state'] = NORMAL
    nbr_picture_entry['state'] = NORMAL
 
    # Status
    remain_pic_label['state'] = NORMAL
    mode_value['text'] = ""
    remain_pic_value['text'] = ""
    remain_time_value['text'] = ""
 
 
def stop():
    if counter_id:
        root.after_cancel(counter_id)
        remain_time_value['text'] = "Terminé"
 
        """Envoi signal externe off"""
        # brdUno.digital[pin].write(0)
 
        messagebox.showinfo("", "Prise annulée")
 
    """Déblocage des widgets une fois la ou les photo(s) terminée(s)"""
    # Mise au point
    button_run_map['state'] = NORMAL
    exposure_intervalometer_value_combobox_map['state'] = NORMAL
    button_stop['state'] = DISABLED
 
    # Intervalomètre
    button_run_intervalometer['state'] = NORMAL
    exposure_intervalometer_value_combobox['state'] = NORMAL
    time_between_combobox['state'] = NORMAL
    nbr_picture_entry['state'] = NORMAL
 
    # Status
    remain_pic_label['state'] = NORMAL
    mode_value['text'] = ""
    remain_pic_value['text'] = ""
    remain_time_value['text'] = ""
 
 
def quitter():
    root.destroy()
    root.quit()
 
 
root = Tk()
root.minsize(455, 310)
root.title("Intervallomètre")
 
""" LabelFrames & Labels ---------------------------------------------------------------------------"""
intervalometer_frame = LabelFrame(root, text="Intervallomètre")
intervalometer_label_frame = Frame(intervalometer_frame)
intervalometer_entries_frame = Frame(intervalometer_frame)
 
status_frame = LabelFrame(root, text="status")
status_frame_label = Frame(status_frame)
status_frame_value = Frame(status_frame)
 
map_frame = LabelFrame(root, text="Mise au point")
 
intervalometer_frame.place(width=240, height=200, x=5, y=5)
intervalometer_label_frame.place(width=145, height=170, x=5)
intervalometer_entries_frame.place(width=80, height=170, x=150)
 
status_frame.place(width=325, height=100, x=5, y=205)
status_frame_label.place(width=110, height=75, x=5)
status_frame_value.place(width=200, height=75, x=115)
 
map_frame.place(width=200, height=200, x=250, y=5)
"""-------------------------------------------------------------------------------------------------"""
 
""" Intervalometer Frame ---------------------------------------------------------------------------"""
# Label frames
exposure_intervalometer_label = Label(intervalometer_label_frame, text="Temps d'exposition :")
time_between_label = Label(intervalometer_label_frame, text="Temps entre prise :")
time_nbr_picture_label = Label(intervalometer_label_frame, text="Nombre de photos :")
 
exposure_intervalometer_label.grid(row=0, sticky=E, ipady=10)
time_between_label.grid(row=1, sticky=E, ipady=10)
time_nbr_picture_label.grid(row=2, sticky=E, ipady=10)
 
# Entry frames
exposure_intervalometer_value_combobox = ttk.Combobox(intervalometer_entries_frame, values=exposure_time)
exposure_intervalometer_value_combobox.current(0)
time_between_combobox = ttk.Combobox(intervalometer_entries_frame, values=[1, 2, 3, 4, 5])
time_between_combobox.current(0)
nbr_picture_entry = Entry(intervalometer_entries_frame)
 
exposure_intervalometer_value_combobox.place(width=50, height=20, y=10)
time_between_combobox.place(width=50, height=20, y=50)
nbr_picture_entry.place(width=50, height=22, y=92)
 
# Bouton
button_run_intervalometer = Button(intervalometer_frame, text="Run", command=run_intervalometer)
button_run_intervalometer.place(width=80, height=30, x=85, y=140)
"""-------------------------------------------------------------------------------------------------"""
 
""" Status Frame -----------------------------------------------------------------------------------"""
# Label frame
mode_label = Label(status_frame_label, text="Mode :")
remain_pic_label = Label(status_frame_label, text="Reste :")
remain_time_label = Label(status_frame_label, text="Temps restant :")
 
mode_label.grid(row=0, sticky=E, ipady=2)
remain_pic_label.grid(row=1, sticky=E, ipady=2)
remain_time_label.grid(row=2, sticky=E, ipady=2)
 
# Value frame
mode_value = Label(status_frame_value)
remain_pic_value = Label(status_frame_value)
remain_time_value = Label(status_frame_value)
 
mode_value.grid(row=0, sticky=W, ipady=2)
remain_pic_value.grid(row=1, sticky=W, ipady=2)
remain_time_value.grid(row=2, sticky=W, ipady=2)
"""-------------------------------------------------------------------------------------------------"""
 
""" map Frame --------------------------------------------------------------------------------------"""
exposure_intervalometer_map = Label(map_frame, text="Temps d'exposition :")
exposure_intervalometer_value_combobox_map = ttk.Combobox(map_frame, values=exposure_time)
exposure_intervalometer_value_combobox_map.current(0)
button_run_map = Button(map_frame, text="Run", command=run_map)
 
exposure_intervalometer_map.place(width=150, height=20, y=20, x=25)
exposure_intervalometer_value_combobox_map.place(width=50, height=20, y=60, x=75)
button_run_map.place(width=80, height=30, x=60, y=105)
"""-------------------------------------------------------------------------------------------------"""
 
""" Bouton root -----------------------------------------------------------------------------------"""
button_stop = Button(root, text="Stop", state=DISABLED, command=stop)
button_stop.place(width=80, height=30, x=350, y=220)
 
button_quit = Button(root, text="Quitter", command=quitter)
button_quit.place(width=80, height=30, x=350, y=270)
"""-------------------------------------------------------------------------------------------------"""
 
root.protocol('WM_DELETE_WINDOW', quitter)
root.mainloop()

J'ai comment� toutes les commandes ext�rieures (Arduino) afin que vous puissiez faire fonctionner le programme.

**wiztricks** · 15/09/2020, 17h58

Salut,

Envoy� par Fred973

bref quelqu'un pourrait m�aiguiller sur la mani�re de faire pour avoir une solution qui pourrait d�compter (photo restantes � prendre) des boucles (temps d'exposition et temps entre pose) dans un environnement tkinter afin de pouvoir garder le contr�le sur l'affichage des labels et l��tat des widgets(combobox, button, etc...)

La m�thode standard est de mettre la partie intervallom�tre dans un thread (comme �� pas de blocage du GUI), �ventuellement en l'emballant dans une "class" histoire d'y accrocher des commandes (pause, stop) et de pouvoir le tester hors tkinter. Puis d'interfacer la chose avec tkinter.

Une m�thode "sans thread" est de remplacer les "sleep" par des appels � .after (de tkinter)... il faut reprendre la conception car �� casse les boucles et on aura des difficult�s � tester hors tkinter.

- W

**Fred973** · 15/09/2020, 18h08

Salut Wiztricks,

Encore merci pour ta r�ponse rapide comme d'habitude

je vais donc regarder les cours sur les threads j'ai d�j� vu quelques infos l� dessus. Concernant .after je l'utilise d�j� pour le mode mise au point et il est vrai que je n'ai pas r�ussi � l'incr�menter dans un "d�compteur de boucle"....

car c'est super efficace !!

merci encore et reviendrai surement � ce sujet .... je laisse encore ouvert la discussion si cela convient.

**Fred973** · 17/09/2020, 12h50

Salut W,

Merci beauoucp pour le tuyau des threads cela fonctionne � merveille maintenant. J'ai pu trouver un mod�le que j'ai bricol� � ma convenance afin d'essayer de comprendre le fonctionnement. Mon seul souci et de reussir � int�rrompre le thread en cours via une action bouton depuis tkinter. J'avoue avoir un peu de mal. J'arrive � le faire en appelant via un event la fonction Threaf_fini(), mais une fois interrompu le thread recommence jusqu'� qu'il soit fini...

La documentation est bonne mais ne m'aide pas assez pour comprendre. Je crois que .join() ou .lock() devrait faire le travail non ? mais comment les appeler ?
Bref je continue ....

Je mets le code de mon 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
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
 
class Intervalometer(threading.Thread):
    def __init__(self, win, res, texp, tbet, nbr_pic):
        threading.Thread.__init__(self)
        self.win = win
        self.res = res
        self.texp = texp
        self.tbet = tbet
        self.nbr_pic = nbr_pic
 
    def run(self):
        for i in range(0, self.nbr_pic):
            brdUno.digital[pin].write(1)
            sleep(self.texp)
            brdUno.digital[pin].write(0)
            sleep(self.tbet)
            self.nbr_pic -= 1
            pic = self.nbr_pic
        self.win.event_generate("<<thread_fini>>")
 
 
thread_resultat = []
 
 
def thread_fini_fonction(e):
    global thread_resultat
 
 
def run_intervalometer():
    """Démarre les prises de vue de l'intervallomètre"""
    global thread_resultat
    global counter_id_intervalometer
 
    mode_value['text'] = "Intervallomètre"
 
    texp = int(exposure_intervalometer_value_combobox.get())
    tbet = int(time_between_combobox.get())
    pic_nbr = int(nbr_picture_entry.get())
 
    """Compteur des photos restantes"""
    # pic_time = int(texp + tbet)
    # total_time = int(pic_nbr * (texp + tbet))
    # remain_pic_nbr = int(total_time / pic_time)
    # remain_pic_value['text'] = 'Reste :', remain_pic_nbr, 'photos.'
 
    """Compteur du temps restant"""
    total_time = int(pic_nbr * (texp + tbet))
    days = divmod(total_time, 86400)
    hours = divmod(days[1], 3600)
    minutes = divmod(hours[1], 60)
    remain_time_value['text'] = "%i h %i min %i sec." % (hours[0], minutes[0], minutes[1])
 
    if total_time > 0:
        counter_id_intervalometer = root.after(1000, expo_time_map, total_time - 1)
    else:
        root.after_cancel(counter_id_intervalometer)
 
    """blocage des widgets durant la photo"""
    button_quit.config(state=DISABLED)
    button_stop.config(state=NORMAL)
    exposure_intervalometer_value_combobox.config(state=DISABLED)
    time_between_combobox.config(state=DISABLED)
    nbr_picture_entry.config(state=DISABLED)
    exposure_intervalometer_value_combobox_map.config(state=DISABLED)
    button_run_map.config(state=DISABLED)
    button_run_intervalometer.config(state=DISABLED)
    button_run_offset.config(state=DISABLED)
    nbr_picture_offset_entry.config(state=DISABLED)
 
    m = Intervalometer(root, thread_resultat, texp, tbet, pic_nbr)
    m.start()
 
============================================================
 
root.bind("<<thread_fini>>", thread_fini_fonction)
button_stop.bind('<Button-1>', thread_fini_fonction)

**wiztricks** · 17/09/2020, 13h45

Salut,

Envoy� par Fred973

La documentation est bonne mais ne m'aide pas assez pour comprendre. Je crois que .join() ou .lock() devrait faire le travail non ? mais comment les appeler ?

Il y a plein d'erreurs dans votre code.

Avant de vouloir r�aliser cette chose l� dans votre application, concentrez vous sur la m�canique en �crivant un code plus simple. Par exemple avec un thread qui d�cr�mente un compteur toutes les x secondes et qui demande � tkinter d'afficher la valeur du compteur.

- W

**Fred973** · 17/09/2020, 16h31

Quelques choses comme �a ?

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
from time import sleep
from threading import Thread
 
 
class Counter(Thread):
    def __init__(self, nbr_pic):
        Thread.__init__(self)
        self.nbr_pic = nbr_pic
 
    def run(self):
        while self.nbr_pic != 0:
            print(self.nbr_pic)
            sleep(1)
            self.nbr_pic -= 1
 
 
count = Counter(5)  # décompte à partir de 5
count.start()
count.join()

**wiztricks** · 17/09/2020, 16h46

Salut,

Envoy� par Fred973

Quelques choses comme �a ?

Etudiez plut�t ��:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
9
10
11
12
from time import sleep
from threading import Thread
 
def do_work(count, shoot):
    while count > 0:
        shoot(count)
        sleep(1)
        count -= 1
 
th = Thread(target=do_work, args=(10, print))
th.start()
th.join()

L'important l� dedans est "shoot".

- W

**Fred973** · 17/09/2020, 16h58

Donc si je comprends bien en appelant la classe Thread les param�tres donn�es dans args= sont les param�tres de la fonction do_work donn� en target dans la classe Thread ? et shoot peut donc "transporter" une fonction ?
en effet c'est bien plus simple que ce que j'ai fait ...

**wiztricks** · 17/09/2020, 18h24

Envoy� par Fred973

en effet c'est bien plus simple que ce que j'ai fait ...

Ce n'est pas plus "simple", c'est plus d�pouill�: on fabrique une fonction qui marche puis on l'ex�cute dans son propre thread plut�t que de tout mettre pelle m�le dans une bo�te "Thread".

Envoy� par Fred973

et shoot peut donc "transporter" une fonction ?

Que shoot soit un alias de print ou une fonction plus sophistiqu�e pour mettre � jour un Label c�t� tkinter... do_work se contente de l'appeler � chaque it�ration avec count en param�tre.

- W

**Fred973** · 17/09/2020, 18h57

Que shoot soit un alias de print ou une fonction plus sophistiqu�e pour mettre � jour un Label c�t� tkinter... do_work se contente de l'appeler � chaque it�ration avec count en param�tre.

- W

Ok j'ai donc essay� de remplacer print par une fonction mais sans gros r�sultats

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
#! /usr/bin/python3.8
# coding:utf-8
from time import sleep
from threading import Thread
from tkinter import *
 
 
def do_work(count, shoot):
    while count > 0:
        shoot(count)
        sleep(1)
        count -= 1
 
 
def run():
    th = Thread(target=do_work, args=(4, print))
    th.start()
    th.join()
 
 
root = Tk()
btn_run = Button(root, text="Run", command=run).pack()
label = Label(root)
label.pack()
root.mainloop()

�a ne fonctionne qu'avec print j'ai essay� avec label.config mais je ne vois pas ou plac� le text= ...

Merci quand m�me de prendre le temps d'aider un pauvre "relou" d�butant en python .....

**wiztricks** · 17/09/2020, 19h45

Salut,

Pas g�nial mais pour rester proche du code que vous avez post�, �� pourrait donner:

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
from time import sleep
from threading import Thread
from tkinter import *
 
def do_work(count, shoot):
    while count > 0:
        shoot(count)
        sleep(1)
        count -= 1
 
def shoot(count):
    root.after(0, lambda: label.configure(text=count))
 
def run():
    th = Thread(target=do_work, args=(4, shoot))
    th.daemon = True
    th.start()
 
 
 
root = Tk()
Button(root, text="Run", command=run).pack()
label = Label(root)
label.pack()
root.mainloop()

Merci quand m�me de prendre le temps d'aider un pauvre "relou" d�butant en python .....

Tant que vous essayez d'apprendre quelque chose plut�t que vouloir qu'on vous serve une soupe pr�te � emporter...

- W

Intervallom�tre sous python

Python

Discussions similaires

Partager

Partager