@@ -1,133 +1,139 | |||||
1 | #!/usr/bin/env python |
|
1 | #!/usr/bin/env python | |
2 | #-*- coding: utf-8 -*- |
|
2 | #-*- coding: utf-8 -*- | |
3 | """Simple python library to drive DLP-TEMP module from www.dlpdesign.com |
|
3 | """Simple python library to drive DLP-TEMP module from www.dlpdesign.com | |
4 | """ |
|
4 | """ | |
5 | import time |
|
5 | import time | |
6 | import sys |
|
6 | import sys | |
7 | import os |
|
7 | import os | |
8 | import matplotlib.pyplot as plt |
|
8 | import matplotlib.pyplot as plt | |
9 | import numpy as np |
|
9 | import numpy as np | |
10 | import serial |
|
10 | import serial | |
|
11 | import struct | |||
11 |
|
12 | |||
12 | __author__ = "Alexis Jeandet" |
|
13 | __author__ = "Alexis Jeandet" | |
13 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" |
|
14 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" | |
14 | __credits__ = [] |
|
15 | __credits__ = [] | |
15 | __license__ = "GPLv2" |
|
16 | __license__ = "GPLv2" | |
16 | __version__ = "1.0.0" |
|
17 | __version__ = "1.0.0" | |
17 | __maintainer__ = "Alexis Jeandet" |
|
18 | __maintainer__ = "Alexis Jeandet" | |
18 | __email__ = "alexis.jeandet@member.fsf.org" |
|
19 | __email__ = "alexis.jeandet@member.fsf.org" | |
19 | __status__ = "Production" |
|
20 | __status__ = "Production" | |
20 |
|
21 | |||
21 | class dlp_temp(object): |
|
22 | class dlp_temp(object): | |
22 | sensors = {0 : b'S', |
|
23 | sensors = {0 : b'S', | |
23 | 1 : b'T', |
|
24 | 1 : b'T', | |
24 | 2 : b'U', |
|
25 | 2 : b'U', | |
25 | } |
|
26 | } | |
26 | aninputs = {0 : b'A', |
|
27 | aninputs = {0 : b'A', | |
27 | 1 : b'B', |
|
28 | 1 : b'B', | |
28 | 2 : b'C', |
|
29 | 2 : b'C', | |
29 | } |
|
30 | } | |
30 | digitin= {0 : b'M', |
|
31 | digitin= {0 : b'M', | |
31 | 1 : b'N', |
|
32 | 1 : b'N', | |
32 | 2 : b'O', |
|
33 | 2 : b'O', | |
33 | } |
|
34 | } | |
34 | digithigh= {0 : b'J', |
|
35 | digithigh= {0 : b'J', | |
35 | 1 : b'K', |
|
36 | 1 : b'K', | |
36 | 2 : b'L', |
|
37 | 2 : b'L', | |
37 | } |
|
38 | } | |
38 | digitlow= {0 : b'G', |
|
39 | digitlow= {0 : b'G', | |
39 | 1 : b'H', |
|
40 | 1 : b'H', | |
40 | 2 : b'I', |
|
41 | 2 : b'I', | |
41 | } |
|
42 | } | |
42 | def __init__(self,port): |
|
43 | def __init__(self,port): | |
43 | self.i=0 |
|
44 | self.i=0 | |
44 | self.__port=serial.Serial(port,timeout=0.5) |
|
45 | self.__port=serial.Serial(port,timeout=0.5) | |
45 |
|
46 | |||
46 | def _byte_to_int(self,byte): |
|
|||
47 | if byte >= 128: |
|
|||
48 | return byte-256 |
|
|||
49 | else: |
|
|||
50 | return byte |
|
|||
51 |
|
||||
52 | def ping(self): |
|
47 | def ping(self): | |
53 | self.__port.write(b"P") |
|
48 | self.__port.write(b"P") | |
54 | return b'Q' == self.__port.read(1) |
|
49 | return b'Q' == self.__port.read(1) | |
55 |
|
50 | |||
56 | def read_sensor(self,index): |
|
51 | def read_sensor(self,index): | |
57 | if index < 3: |
|
52 | if index < 3: | |
58 | self.__port.write(self.sensors.get(index)) |
|
53 | self.__port.write(self.sensors.get(index)) | |
59 | dat=self.__port.read(9) |
|
54 | dat=self.__port.read(9) | |
60 | test=( self._byte_to_int(dat[0]) + (self._byte_to_int(dat[1])*256) ) |
|
55 | temp=float(struct.unpack( "h", dat[:2])[0])*0.0625 | |
61 | temp=float(test)*0.0625 |
|
|||
62 | return temp #(temp-32.0)/1.8 |
|
56 | return temp #(temp-32.0)/1.8 | |
63 | raise UserWarning("Parameter out of bound") |
|
57 | raise UserWarning("Parameter out of bound") | |
64 |
|
58 | |||
65 | def read_analog_in(self,index): |
|
59 | def read_analog_in(self,index): | |
66 | if index < 3: |
|
60 | if index < 3: | |
67 | self.__port.write(self.aninputs.get(index)) |
|
61 | self.__port.write(self.aninputs.get(index)) | |
68 | dat=self.__port.read(2) |
|
62 | dat=self.__port.read(2) | |
69 | test=( self._byte_to_int(dat[0]) + (self._byte_to_int(dat[1])*256) ) |
|
63 | val=float(struct.unpack( "h", dat[:2])[0])/512.0 | |
70 | val=float(test)/512.0 |
|
|||
71 | return val |
|
64 | return val | |
72 | raise UserWarning("Parameter out of bound") |
|
65 | raise UserWarning("Parameter out of bound") | |
73 |
|
66 | |||
74 | def digit_in(self,index): |
|
67 | def digit_in(self,index): | |
75 | if index < 3: |
|
68 | if index < 3: | |
76 | self.__port.write(self.digitin.get(index)) |
|
69 | self.__port.write(self.digitin.get(index)) | |
77 | dat=self.__port.read(1) |
|
70 | dat=self.__port.read(1) | |
78 | return dat |
|
71 | return dat | |
79 | raise UserWarning("Parameter out of bound") |
|
72 | raise UserWarning("Parameter out of bound") | |
80 |
|
73 | |||
81 | def digit_out(self,index,val): |
|
74 | def digit_out(self,index,val): | |
82 | if index < 3: |
|
75 | if index < 3: | |
83 | if val: |
|
76 | if val: | |
84 | self.__port.write(self.digithigh.get(index)) |
|
77 | self.__port.write(self.digithigh.get(index)) | |
85 | else: |
|
78 | else: | |
86 | self.__port.write(self.digitlow.get(index)) |
|
79 | self.__port.write(self.digitlow.get(index)) | |
87 | raise UserWarning("Parameter out of bound") |
|
80 | raise UserWarning("Parameter out of bound") | |
88 |
|
81 | |||
89 | @property |
|
82 | @property | |
90 | def sensor1(self): |
|
83 | def sensor1(self): | |
91 | return self.read_sensor(0) |
|
84 | return self.read_sensor(0) | |
92 |
|
85 | |||
93 | @property |
|
86 | @property | |
94 | def sensor2(self): |
|
87 | def sensor2(self): | |
95 | return self.read_sensor(1) |
|
88 | return self.read_sensor(1) | |
96 |
|
89 | |||
97 | @property |
|
90 | @property | |
98 | def sensor3(self): |
|
91 | def sensor3(self): | |
99 | return self.read_sensor(2) |
|
92 | return self.read_sensor(2) | |
100 |
|
93 | |||
101 | @property |
|
94 | @property | |
102 | def AN1(self): |
|
95 | def AN1(self): | |
103 | return self.read_analog_in(0) |
|
96 | return self.read_analog_in(0) | |
104 | @property |
|
97 | @property | |
105 | def AN2(self): |
|
98 | def AN2(self): | |
106 | return self.read_analog_in(1) |
|
99 | return self.read_analog_in(1) | |
107 | @property |
|
100 | @property | |
108 | def AN3(self): |
|
101 | def AN3(self): | |
109 | return self.read_analog_in(2) |
|
102 | return self.read_analog_in(2) | |
110 |
|
103 | |||
111 | @property |
|
104 | @property | |
112 | def GP2(self): |
|
105 | def GP2(self): | |
113 | return self.digit_in(0) |
|
106 | return self.digit_in(0) | |
114 | @GP2.setter |
|
107 | @GP2.setter | |
115 | def GP2(self,value): |
|
108 | def GP2(self,value): | |
116 | return self.digit_out(0,value) |
|
109 | return self.digit_out(0,value) | |
117 |
|
110 | |||
118 | @property |
|
111 | @property | |
119 | def GP0(self): |
|
112 | def GP0(self): | |
120 | return self.digit_in(1) |
|
113 | return self.digit_in(1) | |
121 | @GP0.setter |
|
114 | @GP0.setter | |
122 | def GP0(self,value): |
|
115 | def GP0(self,value): | |
123 | return self.digit_out(1,value) |
|
116 | return self.digit_out(1,value) | |
124 |
|
117 | |||
125 | @property |
|
118 | @property | |
126 | def GP4(self): |
|
119 | def GP4(self): | |
127 | return self.digit_in(2) |
|
120 | return self.digit_in(2) | |
128 | @GP4.setter |
|
121 | @GP4.setter | |
129 | def GP4(self,value): |
|
122 | def GP4(self,value): | |
130 | return self.digit_out(2,value) |
|
123 | return self.digit_out(2,value) | |
131 |
|
124 | |||
|
125 | ||||
|
126 | def main(argv): | |||
|
127 | if len(argv)==4: | |||
|
128 | print(argv[3]) | |||
|
129 | if len(argv)>=3: | |||
|
130 | dlp=dlp_temp(argv[0]) | |||
|
131 | while(True): | |||
|
132 | readout=[dlp.read_sensor(i) for i in range(int(argv[1]))] | |||
|
133 | print("{date}\t{values}".format(date=time.strftime("%Y-%m-%dT%H:%M:%S"),values="\t".join([str(x) for x in readout] ))) | |||
|
134 | time.sleep(float(argv[2])) | |||
|
135 | ||||
|
136 | ||||
132 | if __name__ == '__main__': |
|
137 | if __name__ == '__main__': | |
133 |
print( |
|
138 | print(sys.argv) | |
|
139 | main(sys.argv[1:]) |
General Comments 0
You need to be logged in to leave comments.
Login now