problème avec un import et un thread

**cFranssen** · 21/04/2011, 12h43

bonjour, j'ai fait un logiciel qui permet(ra)

d'afficher les données météo d'une station sur le pc ( via rs232) . Comme une image vau toujours mieux qu'un long blabla, je joint une image de l'erreur

**airod** · 21/04/2011, 13h44

un petit morceau de code incriminé peut permettre de nous aiguiller pour vous aider et/ou une description du fonctionnement du programme.

a quoi sont utilisés les threads?

Cependant, il me parait que self.t_ext n'existe pas dans le contexte.

Peut on voir la class utilisée?

**cFranssen** · 21/04/2011, 14h57

t_int existe dans ws3500.py

voici le code (ws3500.py) de qui va chercher les données dans la satation:

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
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
704
705
706
# -*- 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
 
	def getAllInfo(self):
		self.info = {'IntTemp': self.t_int, 'ExtTemp': self.t_ext, 'PtRosee': self.p_rosee, 'IntHum': self.h_int, 'ExtHum': self.h_ext, 'Tendency': t_tendency, 'IntPress': self.p_rel}
		return self.info

et voici celui qui inclut ws3500.py et qui devrait normalemen, grace au time, relancer ws3500 toute les secondes mais il ne le fait qu'une seul fois (donc pas de beug dans ws3500) mais à la deuxième fois il plante.

en fait, je ne peu faire d'include qu'une seul fois et non toute les secondes.

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
# -*- coding:Utf-8 -*-
import gtk
import sqlite3
import threading
import time
import pygtk
pygtk.require('2.0')
import threading
import gobject
 
 
 
class MeteoUI:
	def __init__(self):
		self.fenetre = gtk.Window(gtk.WINDOW_TOPLEVEL)
		self.fenetre.set_title("Pymeteo by cFranssen")
		self.fenetre.set_position(gtk.WIN_POS_CENTER)
		self.fenetre.connect("destroy", gtk.main_quit)
		self.fenetre.set_border_width(5)
		self.fenetre.set_resizable(False)
		self.boiteh = gtk.HBox(False, 20)
		self.boiteh.set_size_request(600, 300)
		self.fenetre.add(self.boiteh)
 
 
		c2 = bd()
 
		self.t = MyTimer(2.0, self.refresh)
		self.t.start()
		self.tableau = []
		a=1
		IntTemp = 0
		a, b = self.T_Int(IntTemp)
		txt=gtk.Label("Temp Int")
		bv = self.boite(a, b, txt, -50, 0, 50)
		self.boiteh.add(bv)
 
		ExtTemp = 0
		a, b = self.T_Ext(ExtTemp)
		txt=gtk.Label("Temp Ext")
		bv = self.boite(a, b, txt, -50, 0, 50)
		self.boiteh.add(bv)
 
		PtRosee = 0
		a, b = self.Pt_Ros(PtRosee)
		txt=gtk.Label("pt rosée")
		bv = self.boite(a, b, txt, 0, 5, 10)
		self.boiteh.add(bv)
 
		IntHum = 0
		a, b = self.H_Int(IntHum)
		txt=gtk.Label("Hum Int")
		bv = self.boite(a, b, txt, 0, 50, 100)
		self.boiteh.add(bv)
 
		ExtHum = 0
		a, b = self.H_Ext(ExtHum)
		txt=gtk.Label("Hum Ext")
		bv = self.boite(a, b, txt, 0, 50, 100)
 
		self.boiteh.add(bv)
 
		IntPress = 0
		a, b = self.P_Int(IntPress)
		txt=gtk.Label("pression")
		bv = self.boite(a, b, txt, 950, 1000, 1050)
		self.boiteh.add(bv)
 
		c2.open()
		c2.insert(IntTemp, ExtTemp, PtRosee, IntHum, ExtHum, IntPress)
		c2.select()
 
 
 
	def main(self):
		self.fenetre.show_all()
		gtk.main()
 
	def T_Int(self,IntTemp):
		if IntTemp>50:
			t=50
		else:
			t=IntTemp
		b=(t/float(100))+0.5
		a=str(IntTemp)
		return a, b
		collections
	def T_Ext(self, ExtTemp):
		if ExtTemp>50:
			t=50
		else:
			t=ExtTemp
		b=(t/float(100))+0.5
		a=str(t)
		return a, b
 
 
	def Pt_Ros(self, PtRosee):
		if PtRosee>50:
			t=50
		else:
			t=PtRosee
		b=(t/float(10))
		a=str(t)
		return a, b
 
	def H_Int(self, IntHum):
		t=IntHum
		b=(t/float(100))
		a=str(t)
		return a, b
 
	def H_Ext(self, ExtHum):
		t=ExtHum
		b=(t/float(100))
		a=str(t)
		return a, b
 
 
 
	def P_Int(self, IntPress):
		v=1050-IntPress
		t=100-v
		b=(t/float(100))
		a=str(IntPress)
		return a, b
 
 
 
 
	def boite(self, a, b, text, gmax,gmi, gmin):
		boitev = gtk.VBox(False, 5)
		boitev.set_size_request(5, 20)
		boitev.pack_start(text)		
 
		boiteh = gtk.HBox(False, 5)
		boiteh.set_size_request(200, 200)
 
		grad=gtk.Label("%s \n-\n-\n-\n-\n-\n%s\n-\n-\n-\n-\n-\n-\n%s" % (gmin, gmi, gmax))
		bp = gtk.ProgressBar() #Creation d'une barre de progression
		bp.set_text(a) # texte pour la barre
		bp.set_size_request(40, 10)
		bp.set_fraction(b) #valeur
		bp.set_orientation(gtk.PROGRESS_BOTTOM_TO_TOP)
 
		self.tableau.append(bp)
 
		boiteh.pack_start(bp)
		boiteh.pack_start(grad)
		boitev.pack_start(boiteh)
 
		return boitev
 
	def refresh(self):
 
		import ws3500
		statmet = ws3500.Station()
		print "Refresh !"
		IntTemp = statmet.getIntTemp()
		IntTemp_a, IntTemp_b = self.T_Int(IntTemp)
		self.tableau[0].set_text(IntTemp_a)
		self.tableau[0].set_fraction(IntTemp_b)
 
		ExtTemp = statmet.getExtTemp()
		ExtTemp_a, ExtTemp_b = self.T_Ext(ExtTemp)
		self.tableau[1].set_text(ExtTemp_a)
		self.tableau[1].set_fraction(ExtTemp_b)
 
		PtRosee = statmet.getPtRosee()
		PtRosee_a, PtRosee_b = self.Pt_Ros(PtRosee)
		self.tableau[2].set_text(PtRosee_a)
		self.tableau[2].set_fraction(PtRosee_b)
 
		IntHum = statmet.getIntHum()
		IntHum_a, IntHum_b = self.H_Int(IntHum)
		self.tableau[3].set_text(IntHum_a)
		self.tableau[3].set_fraction(IntHum_b)
 
		ExtHum = statmet.getExtHum()
		ExtHum_a, ExtHum_b = self.H_Ext(ExtHum)
		self.tableau[4].set_text(ExtHum_a)
		self.tableau[4].set_fraction(ExtHum_b)
 
		IntPress = statmet.getIntPress()
		IntPress_a, IntPress_b = self.P_Int(IntPress)
		self.tableau[5].set_text(IntPress_a)
		self.tableau[5].set_fraction(IntPress_b)
 
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 real, ExtHum real, 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	
 
 
 
 
class MyTimer:
    def __init__(self, tempo, target, args= [], kwargs={}):
        self._target = target
        self._args = args
        self._kwargs = kwargs
        self._tempo = tempo
 
    def _run(self):
        self._timer = threading.Timer(self._tempo, self._run)
        self._timer.start()
        self._target(*self._args, **self._kwargs)
 
    def start(self):
        self._timer = threading.Timer(self._tempo, self._run)
        self._timer.start()
 
 
 
if __name__ == "__main__":
	gobject.threads_init()
 
	ui = MeteoUI()
	ui.main()

merci d'avance pour votre aide

**Loenix** · 21/04/2011, 16h05

Bonjour,

En effet avec le code c'est quand même un peu mieux ^^.
A vrai dire, je n'ai pas très bien compris votre probleme. Cherchez vous a rafraichir les données toutes les secondes ?

SI oui, inutile de créer une classe de thread, gobject intègre un timer déjà et il suffit de l'appeller de cette manière

Code :

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

gobject.timeout_add(1000, self.actualiser)

1000 ms = 1 s

EN revanche, pour dire à gobject de continuer d'actualiser, il faut obligatoire que votre fonctionactualiser retourne "True", dans le cas contraire, ce dernier s'arrete.

**VinsS** · 21/04/2011, 16h34

Ce n'est pas t_int qi fait défaut mais t_ext.

t_ext est défini ici:
ligne 662

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

C'est le seul endroit du code où cette variable est instanciée.

Tu dis que ça marche à la première actualisation et plus à la seconde, c'est peut-être là qu'est le problème.

Mets quelques "print" judicieux dans ta classe Station, pour voir ce qui s'y passe.

**cFranssen** · 21/04/2011, 17h09

j'avais essayer avec gobject mais il était planter par la partie graphique

et il ne bloque pas à t_int ou t_ext mais tout simplement le premier qu'il rencontre.

je dis qu'il plante à la deuxième actualisation car il importe une deuxième fois les données.

en fait, il plante à la deuxième fois qu'il passe sur "import ws3500" et si je le fais au dévut, il garde toujours le même données évidemment ...

**Loenix** · 21/04/2011, 17h34

Pourquoi importer la bibliothèque plusieurs fois ?

A chaque refresh vous importez "ws3500"

**cFranssen** · 21/04/2011, 17h38

pour avoir les nouvelles données car c'est ws3500 qui va "les chercher sur la station "

**Loenix** · 21/04/2011, 17h58

Une fois que la bibliothèque est appellé, inutile de la re-appeller. Lorsque l'on charge un module comme le votre, ce dernier met a votre disposition toutes les classes et fonctions présentent dans le module et ce, pour toute la durée du processus, je vous conseille d'ailleurs de l'importer avec les autres au tout début de votre script.

**cFranssen** · 21/04/2011, 18h54

je l'ai mit au début avec les autre et cela ne change rien

**Loenix** · 21/04/2011, 19h13

Nous allons donc décortiquer votre code en partant de l'origine du message d'erreur:

Pour lui, il y a une erreur car il ne connait pas self.t_ext.

Il faut voir a quel moment il devrait être définit, ici dans la fonction __init__ :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
try:
    self.ws = WS3500(ser)
    self.meteo_data = self.ws.load_main_data()
    if self.meteo_data:
        self.t_ext = self.ws.temp_ext(self.meteo_data)
except serial.SerialException, e:
    print "SerialException :", e
except Exception, e:
    print "Exception :", e
finally:
    ser.close()

Nous pouvons voir que lorsque l'on lance le code, il n'y a rien d'affiché concernant : SerialException ou Exception, ce n'ai donc pas une erreur dans le try

Il ne rentre donc pas dans self.meteo_data (= False). Il faudrait donc se demander pourquoi cette variable est mit a NULL après quelques lancement.

Je vous avoue que je ne vais pas tester tout le code ^^.
Après, je ne sais pas comment fonctionne votre code exactement, je ne sais pas si vous êtes obligé de tout relancer pour que cela actualise les données, mais n'y a t'il pas un moyen dans votre class WS3500 de récupèrer les données et de les actualiser sans pour autant demander a réinitiliser la classe ?

Je pensais à un truc dans ce genre :

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
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)
                self.ws = WS3500(ser)
 
        def update(self):
		try:
			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()

Après il ne faudrai plus dans le refresh demander a relancer station, mais plutot a faire sa :

Code :

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

1
2
3
4
5
def __init__(self):
    self.station = Station()
 
def refresh(self):
    self.station.update()

SI cela ne fonctionne pas, pouvez vous essayer de m'expliquer a quel moment s'actualise vraiment les informations.

Bon courage

**cFranssen** · 21/04/2011, 19h48

donc voilà station :

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
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)
 
	def update(self):
		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
 
 
	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
 
	def getAllInfo(self):
		self.info = {'IntTemp': self.t_int, 'ExtTemp': self.t_ext, 'PtRosee': self.p_rosee, 'IntHum': self.h_int, 'ExtHum': self.h_ext, 'Tendency': t_tendency, 'IntPress': self.p_rel}
		return self.info

et voilà refresh:

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
def refresh(self):
		self.station = ws35000.Station()
 
 
		statmet = self.station.update()
		print "Refresh !"
		IntTemp = statmet
		IntTemp_a, IntTemp_b = self.T_Int(IntTemp)
		self.tableau[0].set_text(IntTemp_a)
		self.tableau[0].set_fraction(IntTemp_b)
 
		ExtTemp = statmet.getExtTemp()
		ExtTemp_a, ExtTemp_b = self.T_Ext(ExtTemp)
		self.tableau[1].set_text(ExtTemp_a)
		self.tableau[1].set_fraction(ExtTemp_b)
 
		PtRosee = statmet.getPtRosee()
		PtRosee_a, PtRosee_b = self.Pt_Ros(PtRosee)
		self.tableau[2].set_text(PtRosee_a)
		self.tableau[2].set_fraction(PtRosee_b)
 
		IntHum = statmet.getIntHum()
		IntHum_a, IntHum_b = self.H_Int(IntHum)
		self.tableau[3].set_text(IntHum_a)
		self.tableau[3].set_fraction(IntHum_b)
 
		ExtHum = statmet.getExtHum()
		ExtHum_a, ExtHum_b = self.H_Ext(ExtHum)
		self.tableau[4].set_text(ExtHum_a)
		self.tableau[4].set_fraction(ExtHum_b)
 
		IntPress = statmet.getIntPress()
		IntPress_a, IntPress_b = self.P_Int(IntPress)
		self.tableau[5].set_text(IntPress_a)
		self.tableau[5].set_fraction(IntPress_b)

et l'erreur:

j'ai déja modifier le code mais je ne comprend pas bien ou vous voulez en venir

**airod** · 21/04/2011, 20h12

bon, comme ca je dirais que le fait de déclarer une variable dans un try est un peu risqué, non...

j'explique, votre fonction update s'éxécute toujours bien... en effet si il y a une erreur, vous faite un print de l'exception, mais vous ne pouvez le voir.

Ensuite dans les autres methodes, vous faites des return deself.t_ext, ect...
mais en effet si update a echoué (passage par un except) les variable self.t_ext, ect... n'existe pas dans le contexte.

Soit il faut tester l'existance de vos variables dans les méthodes de retour (getIntTemp),soit faire en sorte que vos variables soient toujours déclarées.

ai je été claire?

exemple :

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
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)
                self.t_int = None
		self.t_ext = None
		self.p_rosee = None
		self.h_int = None
		self.h_ext = None
		self.tendency =None
 
	def update(self):
		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
 
			
	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
		
	def getAllInfo(self):
		self.info = {'IntTemp': self.t_int, 'ExtTemp': self.t_ext, 'PtRosee': self.p_rosee, 'IntHum': self.h_int, 'ExtHum': self.h_ext, 'Tendency': t_tendency, 'IntPress': self.p_rel}
		return self.info

Cependant je pense que quelques autres ajustements seront encore nécessaire.

**cFranssen** · 22/04/2011, 14h27

c'est fait, voilà l'erreur:

**PauseKawa** · 22/04/2011, 14h57

Bonjour,

C'est moi ou vous vous compliquez la vie ? Enlevez le try et regardez l'erreur, non ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
    def update(self):
        self.ws = WS3500(ser) # Ici ?
	    self.meteo_data = self.ws.load_main_data() # Là ?
        if self.meteo_data: # Ou dans tout ceci ?
            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)

@+

**airod** · 22/04/2011, 15h20

en effet, le mieux c'est de voir l'erreur de départ.

sinon, c'est ce que j'ai dis en fin de post précédent, il doit y avoir d'autres ajustement a apporter a ton code si tu utilise ce que j'ai mis en exemple.

Il faut comprendre que dans ton cas, utilise les try catch le plus tard possible dans ton code. Fait en sorte que les méthodes de tes classes renvoie toujours un résultat prévu.

par exemple : (JE DIS BIEN "PAR EXEMPLE" et non solution)

Code :

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

1
2
3
4
5
def getIntTemp(self):
                if self.t_int:
		    return self.t_int
                else:
                    return 0

mais cela ne doit pas t'empêcher de savoir pourquoi la méthode "update" echoue. Est ce normal ou non. Est ce que tu as mis un try/except sachant pertinement que le traitment peut echouer ?

**Loenix** · 22/04/2011, 17h07

PauseKawa >> Sa ne sert a rien d'enlever le "try" puisqu'au passage dans la fonction il n'y a pas de print "Exception :", il n'y a donc pas d'erreur dans le try sinon sa irai dans le except.

**cFranssen** · 22/04/2011, 17h10

premièrement, ce n'est pas moi qui ai coder le fichier ws3500 mais je l'ai simplement modifier pour pouvoir récupérer les données dans un autre fichier.

cependant, j'ai avancer un peu car il me dit quelque fois le résultat puis il dit qu'il y a trop de fichier utilisant ttys0 (err no 24).

cela fonctionne car j'ai utiliser la méthode de airod

merci d'avavnce de votre aide

problème avec un import et un thread

Python

Discussions similaires

Partager

Partager