relancer une def toute les minutes

bonjour, je fais un logiciel en python dans le quel je récupère les données d'une station météo. j'aimerais savoir comment je peu relancer la partie du programme toute les minutes pour mettre les données a jours.

regarde du coté de time.sleep() du module time ca devrait t'aider.

Bonsoir,

Citation:

Envoyé par cFranssen

bonjour, je fais un logiciel en python dans le quel je récupère les données d'une station météo. j'aimerais savoir comment je peu relancer la partie du programme toute les minutes pour mettre les données a jours.

Citation:

Envoyé par airod

regarde du coté de time.sleep() du module time ca devrait t'aider.

Si le but principal en est de récupérer les données oui. Sinon time.sleep() est bloquant (i.e Le programme principal s'arrête durant le time.sleep. Il existe des options, style threads entre autre).
Des précessions sur le sujet cFranssen (voir du code) ?

@+

re, voilà le code de l'affichage graphique et autre qui va chercher les données dans le 2ème 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
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
# -*- coding:Utf-8 -*-
import gtk	
import ws3500
import sqlite3
 
class direct:
 
	def T_Int(self,IntTemp):
		if IntTemp>50:
			t=50
		else:
			t=IntTemp
		b=(t/float(100))+0.5
		a=str(t)
		barreProgression = gtk.ProgressBar() #Creation d'une barre de progression
		barreProgression.set_text(a) #Définir un texte pour la barre
		barreProgression.set_fraction(b) #Définir un nouveau pourcentage
		barreProgression.set_orientation(gtk.PROGRESS_BOTTOM_TO_TOP)
		boiteV.pack_start(barreProgression, True, True, True)
 
	def T_Ext(self, ExtTemp):
		if ExtTemp>50:
			t=50
		else:
			t=ExtTemp
		b=(t/float(100))+0.5
		a=str(t)
		barreProgression = gtk.ProgressBar() #Creation d'une barre de progression
		barreProgression.set_text(a) #Définir un texte pour la barre
		barreProgression.set_fraction(b) #Définir un nouveau pourcentage
		barreProgression.set_orientation(gtk.PROGRESS_BOTTOM_TO_TOP)
		boiteV.pack_start(barreProgression, True, True, True)
 
	def Pt_Ros(self, PtRosee):
		if PtRosee>50:
			t=50
		else:
			t=PtRosee
		b=(t/float(10))
		a=str(t)
		barreProgression = gtk.ProgressBar() #Creation d'une barre de progression
		barreProgression.set_text(a) #Définir un texte pour la barre
		barreProgression.set_fraction(b) #Définir un nouveau pourcentage
		barreProgression.set_orientation(gtk.PROGRESS_BOTTOM_TO_TOP)
		boiteV.pack_start(barreProgression, True, True, True)
 
	def H_Int(self, IntHum):
		t=IntHum
		b=(t/float(100))
		a=str(t)
		barreProgression = gtk.ProgressBar() #Creation d'une barre de progression
		barreProgression.set_text(a) #Définir un texte pour la barre
		barreProgression.set_fraction(b) #Définir un nouveau pourcentage
		barreProgression.set_orientation(gtk.PROGRESS_BOTTOM_TO_TOP)
		boiteV.pack_start(barreProgression, True, True, True)
 
	def H_Ext(self, ExtHum):
		t=ExtHum
		b=(t/float(100))
		a=str(t)
		barreProgression = gtk.ProgressBar() #Creation d'une barre de progression
		barreProgression.set_text(a) #Définir un texte pour la barre
		barreProgression.set_fraction(b) #Définir un nouveau pourcentage
		barreProgression.set_orientation(gtk.PROGRESS_BOTTOM_TO_TOP)
		boiteV.pack_start(barreProgression, True, True, True)
 
	def P_Int(self, IntPress):
		v=1050-IntPress
		t=100-v
		b=(t/float(100))
		a=str(IntPress)
		barreProgression = gtk.ProgressBar() #Creation d'une barre de progression
		barreProgression.set_text(a) #Définir un texte pour la barre
		barreProgression.set_fraction(b) #Définir un nouveau pourcentage
		barreProgression.set_orientation(gtk.PROGRESS_BOTTOM_TO_TOP)
		boiteV.pack_start(barreProgression, True, True, True)
 
class bd:
	def __init__(self):
		self.conn = sqlite3.connect('bd_ws3500')
		self.c = self.conn.cursor()
 
	def open(self):
		self.c.execute("create table if not exists data (IntTemp real, ExtTemp real, PtRosee real, IntHum int, ExtHum int, IntPress real)")
 
	def insert(self, IntTemp, ExtTemp, PtRosee, IntHum, ExtHum, IntPress):
		self.c.execute("insert into data values (%s, %s, %s, %s, %s, %s)" %(IntTemp, ExtTemp, PtRosee, IntHum, ExtHum, IntPress))
		self.conn.commit()
 
	def select(self):
		self.c.execute('select * from data')
 
		for row in self.c:
			print row
 
 
if __name__ == "__main__":
	fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
	fenetre.set_title("Pymeteo by cFranssen")
	fenetre.set_position(gtk.WIN_POS_CENTER)
	fenetre.connect("destroy", gtk.main_quit)
	fenetre.set_border_width(20)
	boiteV = gtk.HBox(False, 10)
	boiteV.set_size_request(300, 400)
	fenetre.add(boiteV)
	statmet = ws3500.Station()
	c1 = direct()
	c2 = bd()
 
	IntTemp = statmet.getIntTemp()
	c1.T_Int(IntTemp)
 
	ExtTemp = statmet.getExtTemp()
	c1.T_Ext(ExtTemp)
 
	PtRosee = statmet.getPtRosee()
	c1.Pt_Ros(PtRosee)
 
	IntHum = statmet.getIntHum()
	c1.H_Int(IntHum)
 
	ExtHum = statmet.getExtHum()
	c1.H_Ext(ExtHum)
 
	IntPress = statmet.getIntPress()
	c1.P_Int(IntPress)
 
	c2.open()
 
	c2.insert(IntTemp, ExtTemp, PtRosee, IntHum, ExtHum, IntPress)
 
	c2.select()
 
 
	print statmet.getTendency()
 
 
	fenetre.show_all()
	gtk.main()

celui qui va chercher les données dans la station météo:

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
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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
# -*- coding:Utf-8 -*-
 
import time
import serial
 
DELAY_CONST = 0.001
MAXRETRIES = 10
HISTORY_BUFFER_ADR = 0x1A0
HISTORY_REC_NO = 1796
SETBIT = 0x12
UNSETBIT = 0x32
 
DEBUG = 0
 
def debug(s, level = 2, tab = 0):
	if DEBUG >= level:
		print " "*tab, s
 
def string2hex(s):
	return " ".join(map(lambda(x):hex(ord(x)), s))
 
class WS3500():
	def __init__(self, ser):
		self.ser = ser
		self._init = False
 
	def _initialize(self):
		debug("initialize()", level=1)
		buff = "U"*2000
 
		self.ser.write(buff)
 
		debug("-DTR", tab=1)
		self.ser.setDTR(0)
		debug("-RTS", tab=1)
		self.ser.setRTS(0)
 
		INIT_WAIT = 500
		i = 0
		while i < INIT_WAIT and not self.ser.getDSR():
			i += 1
			time.sleep(DELAY_CONST)
		if i == INIT_WAIT:
			debug("timeout 1", level=1)
			return 0
		i = 0
 
		time.sleep(DELAY_CONST)
		while i < INIT_WAIT and self.ser.getDSR():
			i += 1
			time.sleep(DELAY_CONST)
		if i != INIT_WAIT:
			debug("+RTS", tab=1)
			self.ser.setRTS(1)
			debug("+DTR", tab=1)
			self.ser.setDTR(1)
		else:
			debug("timeout 2", level=1)
			return 0
 
		self.ser.write(buff)
 
		self._init = True
 
		return 1
 
	def _read_safe(self, address, number):
		debug("read_safe(%i, %i)" % (address, number), level=1)
		readdata = ""
		readdata2 = ""
		nb_tests = 1
		for j in range(MAXRETRIES):
			self._write_data(address, 0, None, tab=1)
			readdata = self._read_data(number, tab=1)
 
			if nb_tests == 2:
				self._write_data(address, 0, None, tab=1)
				readdata2 = self._read_data(number, tab=1)
 
				if readdata == readdata2:
					if readdata == chr(0) * number or readdata == "":
						debug("--> only zeros", level=1, tab=1)
						self._init = False
						time.sleep(0.1)
						self._initialize()
					else:
						break
				else:
					debug("--> not identical", level=1, tab=1)
			else:
				if readdata == chr(0) * number or readdata == "":
					debug("--> only zeros", level=1, tab=1)
				else:
					break
 
		if j == MAXRETRIES:
			return -1
 
		return readdata
 
	def _read_data(self, number, tab=0):
		debug("read_data(%i)" % number, level=1, tab=tab)
		command = 0xa1
		readdata = ""
 
		if self._write_byte(command, tab=tab+1):
			for i in range(number):
				b = self._read_byte(tab=tab+1)
				readdata = readdata + chr(b)
				if i + 1 < number:
					self._read_next_byte_seq(tab=tab+1)
 
			self._read_last_byte_seq(tab=tab+1)
 
			debug("--> %s" % string2hex(readdata), level=1, tab=tab)
 
			return readdata
		else:
			debug("--> erreur read_data", level=1, tab=tab)
			return ""
 
	def _write_data(self, address, number, writedata, tab=0):
		debug("write_data(%s, %i)" % (address, number), level=1, tab=tab)
		command = 0xa0
		i = -1
 
		self._write_byte(command, tab=tab+1)
		self._write_byte(address/256, tab=tab+1)
		self._write_byte(address%256, tab=tab+1)
 
		if writedata != None:
			for i in range(number):
				self._write_byte(ord(writedata[i]), tab=tab+1)
 
		debug("-DTR", tab=tab)
		self.ser.setDTR(0)
		debug("-RTS", tab=tab)
		self.ser.setRTS(0)
		debug("+RTS", tab=tab)
		self.ser.setRTS(1)
		debug("+DTR", tab=tab)
		self.ser.setDTR(1)
		debug("-RTS", tab=tab)
		self.ser.setRTS(0)
 
		return i
 
	def _read_next_byte_seq(self, tab=0):
		debug("read_next_byte_seq()", level=1, tab=tab)
		self._write_bit(0)
		debug("-RTS", tab=tab)
		self.ser.setRTS(0)
 
	def _read_last_byte_seq(self, tab=0):
		debug("read_last_byte_seq()", level=1, tab=tab)
		debug("+RTS", tab=tab)
		self.ser.setRTS(1)
		debug("-DTR", tab=tab)
		self.ser.setDTR(0)
		debug("-RTS", tab=tab)
		self.ser.setRTS(0)
		debug("+RTS", tab=tab)
		self.ser.setRTS(1)
		debug("+DTR", tab=tab)
		self.ser.setDTR(1)
		debug("-RTS", tab=tab)
		self.ser.setRTS(0)
 
	def _read_bit(self, tab=0):
		debug("read_bit()", level=1, tab=tab)
		debug("-DTR", tab=tab)
		self.ser.setDTR(0)
		status = self.ser.getCTS()
		debug("CTS ->" + str(status), tab=tab)
		debug("+DTR", tab=tab)
		self.ser.setDTR(1)
 
		debug("--> %i" % int(not status), level=1, tab=tab)
 
		return int(not status)
 
	def _write_bit(self, bit, tab=0):
		debug("write_bit(%i)" % bit, level=1, tab=tab)
		if bit:
			debug("->-RTS", tab=tab)
			self.ser.setRTS(0)
		else:
			debug("->+RTS", tab=tab)
			self.ser.setRTS(1)
		debug("-DTR", tab=tab)
		self.ser.setDTR(0)
		debug("+DTR", tab=tab)
		self.ser.setDTR(1)
 
	def _read_byte(self, tab=0):
		debug("read_byte()", level=1, tab=tab)
		byte = 0
 
		for i in range(8):
			byte *= 2
			byte += self._read_bit(tab=tab+1)
 
		debug("--> %i - %s" % (byte, hex(byte)), level=1, tab=tab)
 
		return byte
 
	def _write_byte(self, byte, tab=0):
		debug("write_byte(%i)" % byte, level=1, tab=tab)
		for i in range(8):
			self._write_bit(byte & 0x80, tab=tab+1)
			byte <<= 1
			byte &= 0xff
 
		debug("-RTS", tab=tab)
		self.ser.setRTS(0)
		status = self.ser.getCTS()
		debug("CTS->" + str(status), tab=tab)
		debug("-DTR", tab=tab)
		self.ser.setDTR(0)
		debug("+DTR", tab=tab)
		self.ser.setDTR(1)
		debug("---> %i" % int(status), level=1, tab=tab)
		if status:
			return 1
		else:
			return 0
 
	def conv_temp(self, data):
		return ((ord(data[1]) & 0xF) * 10 + (ord(data[0]) >> 4) + (ord(data[0]) & 0xF) / 10.0) - 40.0
 
	def conv_datetime(self, data):
		minute = (ord(data[0]) >> 4) + (ord(data[1]) & 0xF) * 10
		heure = (ord(data[1]) >> 4) + (ord(data[2]) & 0xF) * 10
		jour = (ord(data[2]) >> 4) + (ord(data[3]) & 0xF) * 10
		mois = (ord(data[3]) >> 4) + (ord(data[4]) & 0xF) * 10
		annee = 2000 + (ord(data[4]) >> 4) + (ord(data[5]) & 0xF) * 10
		return "%04i-%02i-%02i %02i:%02i" % (annee, mois, jour, heure, minute)
 
	def conv_datetime2(self, data):
		minute = (ord(data[0]) >> 4) * 10 + (ord(data[0]) & 0xF)
		heure = (ord(data[1]) >> 4) * 10 + (ord(data[1]) & 0xF)
		jour = (ord(data[2]) >> 4) * 10 + (ord(data[2]) & 0xF)
		mois = (ord(data[3]) >> 4) * 10 + (ord(data[3]) & 0xF)
		annee = 2000 + (ord(data[4]) >> 4) * 10 + (ord(data[4]) & 0xF)
		return "%04i-%02i-%02i %02i:%02i" % (annee, mois, jour, heure, minute)
 
	def getTemp(self, address, meteo_data = None):
		l = 2
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		return self.conv_temp(data_read)
 
	def getTempBCD(self, address, meteo_data = None):
		l = 2
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		return (ord(data_read[1]) >> 4) * 10 + (ord(data_read[1] )& 0xF) + (ord(data_read[0]) >> 4) / 10.0 - 40.0
 
	def getDateTime(self, address, meteo_data = None):
		l = 6
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		return self.conv_datetime(data_read)
 
	def getDateTime2(self, address, meteo_data = None):
		l = 5
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		return self.conv_datetime2(data_read)
 
	def getHumidity(self, address, meteo_data = None):
		l = 1
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		return (ord(data_read[0]) >> 4) * 10 + (ord(data_read[0]) & 0xf)
 
	def getPressure(self, address, meteo_data = None):
		l = 3
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		return (ord(data_read[2]) & 0xF) * 1000 + (ord(data_read[1]) >> 4) * 100 + (ord(data_read[1]) & 0xF) * 10 + (ord(data_read[0]) >> 4) + (ord(data_read[0]) & 0xF) / 10.0
 
	def temp_int(self, meteo_data = None):
		address = 0x26
 
		return self.getTemp(address, meteo_data)
 
	def temp_ext(self, meteo_data = None):
		address = 0x3D
 
		return self.getTemp(address, meteo_data)
 
	def temperature_indoor_minmax(self, meteo_data = None):
		address_min = 0x28
		address_max = 0x2B
		address_mintime = 0x2C
		address_maxtime = 0x31
 
		data = []
		data.append(self.getTempBCD(address_min, meteo_data))
		data.append(self.getTemp(address_max, meteo_data))
		data.append(self.getDateTime(address_mintime, meteo_data))
		data.append(self.getDateTime(address_maxtime, meteo_data))
 
		return data
 
	def temperature_outdoor_minmax(self, meteo_data = None):
		address_min = 0x3F
		address_max = 0x42
		address_mintime = 0x43
		address_maxtime = 0x48
 
		data = []
		data.append(self.getTempBCD(address_min, meteo_data))
		data.append(self.getTemp(address_max, meteo_data))
		data.append(self.getDateTime(address_mintime, meteo_data))
		data.append(self.getDateTime(address_maxtime, meteo_data))
 
		return data
 
	def dewpoint(self, meteo_data = None):
		address = 0x6B
 
		return self.getTemp(address, meteo_data)
 
	def dewpoint_minmax(self, meteo_data = None):
		address_min = 0x6D
		address_max = 0x70
		address_mintime = 0x71
		address_maxtime = 0x76
 
		data = []
		data.append(self.getTempBCD(address_min, meteo_data))
		data.append(self.getTemp(address_max, meteo_data))
		data.append(self.getDateTime(address_mintime, meteo_data))
		data.append(self.getDateTime(address_maxtime, meteo_data))
 
		return data
 
	def humidity_indoor(self, meteo_data = None):
		address = 0x81
 
		return self.getHumidity(address, meteo_data)
 
	def humidity_outdoor(self, meteo_data = None):
		address = 0x90
 
		return self.getHumidity(address, meteo_data)
 
	def humidity_indoor_minmax(self, meteo_data = None):
		address_min = 0x82
		address_max = 0x83
		address_mintime = 0x84
		address_maxtime = 0x89
 
		data = []
		data.append(self.getHumidity(address_min, meteo_data))
		data.append(self.getHumidity(address_max, meteo_data))
		data.append(self.getDateTime2(address_mintime, meteo_data))
		data.append(self.getDateTime2(address_maxtime, meteo_data))
 
		return data
 
	def humidity_outdoor_minmax(self, meteo_data = None):
		address_min = 0x91
		address_max = 0x92
		address_mintime = 0x93
		address_maxtime = 0x98
 
		data = []
		data.append(self.getHumidity(address_min, meteo_data))
		data.append(self.getHumidity(address_max, meteo_data))
		data.append(self.getDateTime2(address_mintime, meteo_data))
		data.append(self.getDateTime2(address_maxtime, meteo_data))
 
		return data
 
	def rel_pressure(self, meteo_data = None):
		address = 0x13D
 
		return self.getPressure(address, meteo_data)
 
	def rel_pressure_minmax(self, meteo_data = None):
		address_min = 0x156
		address_max = 0x14C
		address_mintime = 0x160
		address_maxtime = 0x15B
 
		data = []
		data.append(self.getPressure(address_min, meteo_data))
		data.append(self.getPressure(address_max, meteo_data))
		data.append(self.getDateTime2(address_mintime, meteo_data))
		data.append(self.getDateTime2(address_maxtime, meteo_data))
 
		return data
 
	def abs_pressure(self, meteo_data = None):
		address = 0x138
 
		return self.getPressure(address, meteo_data)
 
	def abs_pressure_minmax(self, meteo_data = None):
		address_min = 0x5F6
		address_max = 0x5F6 + 12
		address_mintime = 0x61E
		address_maxtime = 0x61E + 5
 
		data = []
		data.append(self.getPressure(address_min, meteo_data))
		data.append(self.getPressure(address_max, meteo_data))
		data.append(self.getDateTime2(address_mintime, meteo_data))
		data.append(self.getDateTime2(address_maxtime, meteo_data))
 
		return data
 
	def tendency_forecast(self, meteo_data = None):
		address = 0x24
		l = 1
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		tendency_values = ["Constant", "Augmentant", "Diminuant"]
		forecast_values = ["Pluvieux", "Nuageux", "Ensoleillé"]
 
		return tendency_values[ord(data_read[0]) >> 4], forecast_values[ord(data_read[0]) & 0xF]
 
	def read_history_info(self):
		if not self._init:
			if not self._initialize():
				return ""
		address = 0x6B2 - 2
		l = 12
		data_read = self._read_safe(address, l)
 
		debug(string2hex(data_read), 1)
 
		data = []
 
		interval = (ord(data_read[1]) & 0xF) * 256 + ord(data_read[0]) + 1
		data.append(interval)
		countdown = ord(data_read[2])*16 + (ord(data_read[1]) >> 4) + 1
		data.append(countdown)
 
		jour = (ord(data_read[0]) >> 4) * 10 + (ord(data_read[0]) & 0xF)
		mois = (ord(data_read[1]) >> 4) * 10 + (ord(data_read[1]) & 0xF)
		annee = 2000 + (ord(data_read[2]) >> 4) * 10 + (ord(data_read[2]) & 0xF)
		data.append((jour, mois, annee))
		no_records = ord(data_read[9])
		data.append(no_records)
 
		return data
 
	def read_history_record(self, data, record_no):
		record = data
 
		minute = ((ord(record[0]) & 0xf0) >> 4)* 10 + (ord(record[0]) & 0xf)
		if minute >= 60:
			return None
		heure = ((ord(record[1]) & 0xf0) >> 4) * 10 + (ord(record[1]) & 0xf)
		jour = ((ord(record[2]) & 0xf0) >> 4) * 10 + (ord(record[2]) & 0xf)
		mois = ((ord(record[3]) & 0xf0) >> 4) * 10 + (ord(record[3]) & 0xf)
		annee = 2000 + ((ord(record[4]) & 0xf0) >> 4) * 10 + (ord(record[4]) & 0xf)
 
		temperature_indoor = ((ord(record[5]) & 0xf0) >> 4) * 10 + (ord(record[5]) & 0xf)
		temperature_indoor += (ord(record[6]) & 0xf) * 100 - 400
		##temperature_indoor /= 10.0
		temperature_outdoor = (ord(record[6]) & 0xf0) >> 4
		temperature_outdoor += ((ord(record[7]) & 0xf0) >> 4) * 100 + (ord(record[7]) & 0xf) * 10 - 400
		##temperature_outdoor /= 10.0
		pressure = ((ord(record[8]) & 0xf0) >> 4) * 10 + (ord(record[8]) & 0xf)
		pressure += ((ord(record[9]) & 0xf0) >> 4) * 1000 + (ord(record[9]) & 0xf) * 100
		pressure += (ord(record[10]) & 0xf) * 10000
		##pressure /= 10.0
		humidity_indoor = (ord(record[10]) & 0xf0) >> 4
		humidity_indoor += (ord(record[11]) & 0xf) * 10
		humidity_outdoor = (ord(record[11]) & 0xf0) >> 4
		humidity_outdoor += (ord(record[12]) & 0xf) * 10
		raincount = ord(record[12]) >> 4
		raincount += ord(record[13]) * 16
		windspeed = (ord(record[15]) & 0xf) * 256 + ord(record[14])
		##windspeed /= 10.0
		if (ord(record[17]) & 0xf) != 1 or ord(record[16]) != 0xFE:
			windgust = (ord(record[17]) & 0xf) * 256 + ord(record[16])
			##windgust /= 10.0
		else:
			windgust = -1
		winddir_degrees = ((ord(record[15]) & 0xF0)>> 4) * 22.5
 
		return ["%04i-%02i-%02i %02i:%02i" % (annee, mois, jour, heure, minute), temperature_indoor, temperature_outdoor, pressure, humidity_indoor, humidity_outdoor, raincount, windspeed, winddir_degrees]
 
	def read_history(self, delai_dernier_releve = 0):
		if not self._init:
			if not self._initialize():
				return ""
		l = 0x7fff - HISTORY_BUFFER_ADR + 1
		nb = 12 * 5 * 20
		l = 18 * nb
		nb_enreg_max = 1750
		address_max = HISTORY_BUFFER_ADR + nb_enreg_max * 18 - 1
		address = HISTORY_BUFFER_ADR
		end_of_data = False
		data = []
		j = 0
		last_record = None
		while not end_of_data and j < MAXRETRIES:
			nb_ok = 0
			j += 1
			debug("read history from address : %s" % hex(address), 1)
			if l + address > address_max:
				l = address_max - address + 1
			if l > 0:
				data_read = self._read_safe(address, l)
 
 
			if data_read:
				for i in range(nb):##range(HISTORY_REC_NO):
					try:
						record = None
						record = self.read_history_record(data_read[i*18:(i+1)*18], i)
					except Exception, e:
						print "exception :", e, i, string2hex(data_read[i*18:(i+1)*18])
						record = None
					if record is None:
						end_of_data = False
						break
					else:
						last_record = record
						nb_ok += 1
					data.append(record)
 
				address += 18 * nb_ok
				if last_record and delai_dernier_releve > 0 :
					try:
						if DateTime.DateTimeFrom(last_record[0]) + DateTime.RelativeDateTime(minutes = delai_dernier_releve) > DateTime.now():
							end_of_data = True
					except:
						pass
			else:
				debug("no data read", 1)
				end_of_data = False
 
		return data
 
	def recording_interval(self, meteo_data = None):
		## returned value by the station :
		##   0 - 1 min
		##   1 - 5 min
		##   2 - 10 min
		##   3 - 15 min
		##   4 - 20 min
		##   5 - 30 min
		##   6 - 60 min
		##   7 - 2 hours
		##   8 - 3 hours
		##   9 - 4 hours
		##   A - 6 hours
		##   B - 8 hours
		##   C - 12 hours
		##   D - 24 hours
		duree = {0 : 1,
				 1 : 5,
				 2 : 10,
				 3 : 15,
				 4 : 20,
				 5 : 30,
				 6 : 60,
				 7 : 120,
				 8 : 180,
				 9 : 240,
				 0xa : 360,
				 0xb : 480,
				 0xc : 720,
				 0xd : 1440}
		l = 1
		address = 0xE3
		if meteo_data is None:
			if not self._init:
				if not self._initialize():
					return ""
			data_read = self._read_safe(address, l)
		else:
			data_read = meteo_data[address:address+l]
 
		return duree[ord(data_read[0]) >> 4]
 
	def load_main_data(self):
		if not self._init:
			if not self._initialize():
				return ""
		address = 0x00
		l = 0x16F
		data_read = self._read_safe(address, l)
 
		return data_read
 
	def light(self, active):
		## Doesn't work
		if not self._init:
			if not self._initialize():
				return ""
		address = 0x16
		l = 1
		if active:
			writedata = chr(SETBIT)
		else:
			writedata = chr(UNSETBIT)
		self._write_data(address, l, writedata, tab=1)
 
 
class Station:
	def __init__(self):
		ser = serial.Serial('/dev/ttyS0', baudrate=300, bytesize=serial.EIGHTBITS, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, timeout=None, writeTimeout=None, rtscts=0, dsrdtr=None, xonxoff=0)
 
		try:
 
			self.ws = WS3500(ser)
			self.meteo_data = self.ws.load_main_data()
 
			if self.meteo_data:
				self.t_int = self.ws.temp_int(self.meteo_data)
				self.t_ext = self.ws.temp_ext(self.meteo_data)
				self.p_rosee = self.ws.dewpoint(self.meteo_data)
				self.h_int = self.ws.humidity_indoor(self.meteo_data)
				self.h_ext = self.ws.humidity_outdoor(self.meteo_data)
				self.tendency = self.ws.tendency_forecast(self.meteo_data)
 
 
				self.p_rel = self.ws.rel_pressure(self.meteo_data)
 
		except serial.SerialException, e:
			print "SerialException :", e
		except Exception, e:
			print "Exception :", e
		finally:
			ser.close()
 
	def getError(self):
		return self.err
 
	def getIntTemp(self):
		return self.t_int
 
	def getExtTemp(self):
		return self.t_ext
 
	def getPtRosee(self):
		return self.p_rosee
 
	def getIntHum(self):
		return self.h_int
 
	def getExtHum(self):
		return self.h_ext
 
	def getTendency(self):
 
		self.tendency = self.ws.tendency_forecast(self.meteo_data)
		self.t_tendency = "le temps sera prochainement %s et %s" % (self.tendency[0], self.tendency[1])
		return self.t_tendency
 
	def getIntPress(self):
		return self.p_rel

le bute est de faire une application qui enregistre les données dans un bd SQLite (déjà fait) et de faire des graphiques (pas encore fait)

il faudrait donc que pendant que le programme va chercher les données sur la station, le reste du programme reste actif car avec un baudrate de 300 il faut environ 1minute pour avoir les données (si je met plus, la station météo m'envoie de conneries (temp= 71° et humidité=110%)

J'avais pensé a des treed mais je ne sais pas comment ça fonctionne ni si c'est ce dont j'ai besoin ici

Bonjour,

Voici l'exemple de la faq gtk pour ce qui est des threads.

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
import threading
import time
import gobject
import gtk
 
gobject.threads_init()
 
class MyThread(threading.Thread):
    def __init__(self, label):
        super(MyThread, self).__init__()
        self.label = label
        self.quit = False
 
    def update_label(self, counter):
        self.label.set_text("Counter: %i" % counter)
        return False
 
    def run(self):
        counter = 0
        while not self.quit:
            counter += 1
            gobject.idle_add(self.update_label, counter)
            time.sleep(0.1)
 
w = gtk.Window()
l = gtk.Label()
w.add(l)
w.show_all()
w.connect("destroy", lambda _: gtk.main_quit())
t = MyThread(l)
t.start()
 
gtk.main()
t.quit = True

A comprendre que counter est facilement remplaçable par les données de statmet.

Bon code

A noter : time.sleep(secs)

@+

oui, les thread sont en effet impératif dans ce cas.

quand je met "time.sleep()" c'est sous entendu, "Une fois trouvé, regardez dans la doc" ;)

je vais regarder la doc tantot mais si j'ai bien compris, il suffit de mettre la partie du prog qui va uploader les données de la sation dans une boucle avec un timesleep de 60 par exemple ?

euh... non!
dans votre cas, si vous ne souhaitez pas bloquer votre interface, il faut mettre en place un system de thread (une recherche dans le forum vous apportera tout ce qu'il faut).

Le thread exécutera en parralléle du programme principal le code qui récupère et traite les informations.
le thread principal (cad celui créé par l'éxécutiuon du programme principal) assure le fonctionnement de l'interface.

Et mettre cette boucle dans un thread (voir run) pour que cela ne soit pas bloquant.

Edit: Oups, Pas vu passer airod...

Regarde ce que fait le code suivant.

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
import threading
import time
import gobject
import gtk
import ws3500
 
gobject.threads_init()
 
class MyThread(threading.Thread):
    def __init__(self, label):
        super(MyThread, self).__init__()
        self.statmet = ws3500.Station()
        self.label = label
        self.quit = False
 
    def update_label(self, IntTemp):
        self.label.set_text("Temp Int : %i" % IntTemp)
        return False
 
    def run(self):
        while not self.quit:
            IntTemp = self.statmet.getIntTemp()
            gobject.idle_add(self.update_label, IntTemp)
            time.sleep(60)
 
w = gtk.Window()
l = gtk.Label()
w.add(l)
w.show_all()
w.connect("destroy", lambda _: gtk.main_quit())
t = MyThread(l)
t.start()
 
gtk.main()
t.quit = True

Salut,

Avec des threads vous ne récupérerez les données que lorsque le pg d'affichage des résultats sera actif.

Comme vous prévoyez de stocker ces mesures dans une BDD, vous pourriez avoir un "programme"/script a part (un process par une thread) qui s'occupera
de la récupération des données depuis la station météo.

Le programme qui les affiche peut se contenter de lire les mises à jours de la BDD toutes les x millisecondes.

- W

Bonjour,

J'avais fait un code comme ça, qui lance une autre fonction toutes les x secondes. Il est indépendant du graphique. Il utilise un threading.Timer à l'intérieur d'un Thread. Pour m'en rappeler, j'ai fait un tuto:

http://python.jpvweb.com/mesrecettes...ion_periodique

Tyrtamos

Salut Tyrtamos,

J'aurais écrit cela ainsi:
Code:

1 2 3 4 5 6 7 class Intervallometre(Threading._Timer): def run(self): while True: self.finished.wait(self.interval) if self.finished.is_set(): break self.function(*self.args, **self.kwargs)
La classe Timer est déjà un thread, mais sa méthode run a été écrite pour n'appeler la fonction qu'une seule fois.
On sous classe et on redéfinit la méthode run pour qu'elle répète tant que l'event self.finished n'est pas positionné à True par la méthode cancel (qui existe déjà).
Note: le défaut de votre exemple étant de créer une thread pour faire les repeat, une autre (Timer) pour effectuer l'attente.

- W
PS: Si personne ne prend le temps de critiquer vos code, vous n'aurez que peu de chances de vous améliorer!!
Ceci dit, je persiste à penser qu'il est préférable, ici, de passer par des process séparés plutôt que par des threads.

Comme quoi lire la source cela aide...
Je ne sais pas si vous le savez mais c'est génial.

Bonjour wiztricks,

Citation:

Envoyé par wiztricks

PS: Si personne ne prend le temps de critiquer vos code, vous n'aurez que peu de chances de vous améliorer!!

Tu as pu constater à plusieurs reprises que, dans la mesure où je comprends l'amélioration proposée, je l'adopte sans état d'âme. Mais je tiens à comprendre le code que j'adopte sans quoi je ne suis pas.

Dans ce cas, modifier la classe threading._Timer est effectivement plus élégant, mais cette possibilité n'est pas dans le manuel, qui comporte d'ailleurs une erreur: threading.Timer est une fonction et pas une classe. Pour connaitre la classe threading._Timer (avec un blanc souligné), il faut examiner le source de la bibliothèque.

Sinon, pour le process, pourquoi pas, et dans ce cas, le module multiprocessing est intéressant, parce qu'il traite les process comme des threads, y compris pour le partage de données.

Merci pour les infos.

Tyrtamos

Bonjour PauseKawa,

Je ne comprends pas ce que tu cherches à faire. Avec a._Timer = tutu, le a._Timer pointe désormais sur la fonction tutu et n'a plus rien à voir avec la classe _Timer.

???

Tyrtamos

edit: ah, je vois que le message en question a disparu.

Citation:

Envoyé par tyrtamos

Dans ce cas, modifier la classe threading._Timer est effectivement plus élégant, mais cette possibilité n'est pas dans le manuel, qui comporte d'ailleurs une erreur: threading.Timer est une fonction et pas une classe. Pour connaitre la classe threading._Timer (avec un blanc souligné), il faut examiner le source de la bibliothèque.

Ce n'est pas un bug, c'est une décision ancienne du développement de Python qui voulait éviter d'avoir des problèmes avec les incompatibilités introduites par 2.4 et 3.0: ils ont fermé un peu les choses côté héritage des sous-types de ... (Timer est un sous type de threads).
Ca râle pour que ce soit relaxé mais en attendant nombre de modules font ce genre de truc.

Si on veut faire "propre", i.e. respecter le caractère privé de la classe _Timer, on peut s'aligner sur le design existante de la façon suivante:
Code:

1 2 3 4 5 6 7 8 9 10 def Intervallometre(*args, **kwds): def run(self): while True: self.finished.wait(self.interval) if self.finished.is_set(): break self.function(*self.args, **self.kwargs) t = threading.Timer(*args, **kwds) t.run = run return t
Le monkey patching d'une classe est quelque chose de plus Pythonique, mais bien que plus propre (on respecte l'API à la lettre), c'est beaucoup plus obscur. De plus pour écrire çà, il faut quand même lire les sources...

Citation:

Sinon, pour le process, pourquoi pas, et dans ce cas, le module multiprocessing est intéressant, parce qu'il traite les process comme des threads, y compris pour le partage de données.

Ni threads, ni multiprocessing: juste deux process indépendants, un qui récupère les données de la station et les sauve en base de données, un autre qui les exploite. Ont-ils d'autres informations à échanger pour justifer qu'ils soient collés via via threading ou multiprocessing?

- W

Petit complément.

Si on en reste à la version thread (que je préfère), il y a une chose intéressante à faire avec certaines bibliothèques graphique comme PyQt4: le thread peut envoyer un message au programme principal (emit => connect) pour lui indiquer qu'une nouvelle mise à jour vient d'être faite. Et la méthode déclenchée à la réception de ce message, peut très bien récupérer l'info fraiche et afficher l'information sur la fenêtre.

Tyrtamos

Quelle différence avec une mise à jour d'une variable ?

Citation:

Quelle différence avec une mise à jour d'une variable ?

Au lieu de tester une variable, la mise à jour devient automatique.

Tyrtamos

Hu?!?

La mise à jour est aussi automatique avec l'exemple GTK proposé.

La différence est que le thread connaît les widgets GTK qui le concernent alors qu'avec les slots Qt, lorsqu'il fait un emit il pourra y avoir 0, 1, 10 widgets mis à jour sans que le thread n'ait à le savoir.

C'est ce qui rend le code "plus souple".

Ceci dit, si l'affichage doit aller récupérer ses données en base, le seul intérêt de mettre la thread de récupération des données et d'affichage dans un même process, c'est juste pour signaler l'arrivée de nouvelles données.

Comme les enregistrements sont horodatés, savoir s'il y en a des nouveaux est assez simple...
- W

Bonsoir,

Je ne connais pas gtk mais s'il existe un équivalent du .after Tkinter une solution sans thread existe.

Citation:

Envoyé par PauseKawa

Bonsoir,

Je ne connais pas gtk mais s'il existe un équivalent du .after Tkinter une solution sans thread existe.

Yes it does
En fait, ces frameworks ne sont que des engins à traiter des événements et dispatcher les actions correspondantes.
- W

Bonjour,

Encore plus facile donc.
C'est a se demander l'utiliter d'un thread dans ce cas (et en général) avec gtk, si ce n'est pour les traitements lourds bien sur.

Pour cFranssen:

Pour répéter ta fonction de lecture toutes les minutes tu dois importer gobject et utiliser .timeout_add.
Soit:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 # -*- coding:Utf-8 -*- import gtk import ws3500 import sqlite3 import gobject .... def lecture(): #code de la lecture des données return True gobject.timeout_add(60000, lecture) gtk.main()
@+