1 | NO CONTENT: new file 100644 |
|
NO CONTENT: new file 100644 |
@@ -0,0 +1,10 | |||||
|
1 | #!/usr/bin/env python | |||
|
2 | #-*- coding: utf-8 -*- | |||
|
3 | __author__ = "Alexis Jeandet" | |||
|
4 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" | |||
|
5 | __credits__ = [] | |||
|
6 | __license__ = "GPLv2" | |||
|
7 | __version__ = "1.0.0" | |||
|
8 | __maintainer__ = "Alexis Jeandet" | |||
|
9 | __email__ = "alexis.jeandet@member.fsf.org" | |||
|
10 | __status__ = "Production" |
@@ -0,0 +1,331 | |||||
|
1 | #!/usr/bin/env python | |||
|
2 | #-*- coding: utf-8 -*- | |||
|
3 | """Simple python library to drive the analog discovery module from www.digilentinc.com | |||
|
4 | """ | |||
|
5 | ||||
|
6 | from ctypes import * | |||
|
7 | import time | |||
|
8 | import sys | |||
|
9 | import os | |||
|
10 | import matplotlib.pyplot as plt | |||
|
11 | import numpy as np | |||
|
12 | ||||
|
13 | __author__ = "Alexis Jeandet" | |||
|
14 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" | |||
|
15 | __credits__ = [] | |||
|
16 | __license__ = "GPLv2" | |||
|
17 | __version__ = "1.0.0" | |||
|
18 | __maintainer__ = "Alexis Jeandet" | |||
|
19 | __email__ = "alexis.jeandet@member.fsf.org" | |||
|
20 | __status__ = "Production" | |||
|
21 | ||||
|
22 | ||||
|
23 | nodev = c_int(0) | |||
|
24 | DwfStateDone = c_int(2) | |||
|
25 | ||||
|
26 | DECIAnalogInChannelCount = c_int(1) | |||
|
27 | DECIAnalogOutChannelCount = c_int(2) | |||
|
28 | DECIAnalogIOChannelCount = c_int(3) | |||
|
29 | DECIDigitalInChannelCount = c_int(4) | |||
|
30 | DECIDigitalOutChannelCount = c_int(5) | |||
|
31 | DECIDigitalIOChannelCount = c_int(6) | |||
|
32 | DECIAnalogInBufferSize = c_int(7) | |||
|
33 | DECIAnalogOutBufferSize = c_int(8) | |||
|
34 | DECIDigitalInBufferSize = c_int(9) | |||
|
35 | DECIDigitalOutBufferSize = c_int(10) | |||
|
36 | ||||
|
37 | trigsrcNone = c_byte(0) | |||
|
38 | trigsrcPC = c_byte(1) | |||
|
39 | trigsrcDetectorAnalogIn = c_byte(2) | |||
|
40 | trigsrcDetectorDigitalIn = c_byte(3) | |||
|
41 | trigsrcAnalogIn = c_byte(4) | |||
|
42 | trigsrcDigitalIn = c_byte(5) | |||
|
43 | trigsrcDigitalOut = c_byte(6) | |||
|
44 | trigsrcAnalogOut1 = c_byte(7) | |||
|
45 | trigsrcAnalogOut2 = c_byte(8) | |||
|
46 | trigsrcAnalogOut3 = c_byte(9) | |||
|
47 | trigsrcAnalogOut4 = c_byte(10) | |||
|
48 | trigsrcExternal1 = c_byte(11) | |||
|
49 | trigsrcExternal2 = c_byte(12) | |||
|
50 | trigsrcExternal3 = c_byte(13) | |||
|
51 | trigsrcExternal4 = c_byte(14) | |||
|
52 | trigAuto = c_byte(254) | |||
|
53 | trigNormal = c_byte(255) | |||
|
54 | ||||
|
55 | AnalogOutNodeCarrier = c_int(0) | |||
|
56 | AnalogOutNodeFM = c_int(1) | |||
|
57 | AnalogOutNodeAM = c_int(2) | |||
|
58 | ||||
|
59 | ||||
|
60 | shapes = {'DC' : 0, | |||
|
61 | 'Sine' : 1, | |||
|
62 | 'Square' : 2, | |||
|
63 | 'Triangle' : 3, | |||
|
64 | 'RampUp' : 4, | |||
|
65 | 'RampDown' : 5, | |||
|
66 | 'Noise' : 6, | |||
|
67 | 'Custom' : 30, | |||
|
68 | 'Play' :31, } | |||
|
69 | ||||
|
70 | closed=False | |||
|
71 | opened=True | |||
|
72 | ||||
|
73 | ||||
|
74 | class discoveryLimits(): | |||
|
75 | class limitRange(): | |||
|
76 | def __init__(self,Min,Max,name="Unknow",unit=""): | |||
|
77 | self.Min = Min | |||
|
78 | self.Max = Max | |||
|
79 | self.name = name | |||
|
80 | self.unit = unit | |||
|
81 | ||||
|
82 | def conform(self,value): | |||
|
83 | if value<self.Min: | |||
|
84 | raise UserWarning("Parameter "+self.name+" out of bound\nValue="+str(value)+"\nForce to "+str(self.Min)) | |||
|
85 | return self.Min | |||
|
86 | if value>self.Max: | |||
|
87 | raise UserWarning("Parameter "+self.name+" out of bound\nValue="+str(value)+"\nForce to "+str(self.Max)) | |||
|
88 | return self.Max | |||
|
89 | return value | |||
|
90 | ||||
|
91 | def printme(self): | |||
|
92 | print(self.name + ":\n Min="+str(self.Min)+" "+self.unit+",Max="+str(self.Max)+" "+self.unit) | |||
|
93 | ||||
|
94 | errors = {0: RuntimeError("No card opened"), | |||
|
95 | 1: UserWarning("Parameter out of bound"), | |||
|
96 | } | |||
|
97 | def __init__(self,libdwf,hdwf): | |||
|
98 | self.limits=[] | |||
|
99 | self.ACQ_IN_RANGES=[0.0] | |||
|
100 | if hdwf.value == nodev.value: | |||
|
101 | return | |||
|
102 | self.__hdwf=hdwf | |||
|
103 | self.__libdwf=libdwf | |||
|
104 | Mind=c_double() | |||
|
105 | Maxd=c_double() | |||
|
106 | Mini=c_int() | |||
|
107 | Maxi=c_int() | |||
|
108 | StepsCount=c_int() | |||
|
109 | Steps=(c_double*32)() | |||
|
110 | self.__libdwf.FDwfAnalogInBufferSizeInfo(self.__hdwf, byref(Mini), byref(Maxi)) | |||
|
111 | self.ACQ_BUF=self.limitRange(Mini.value,Maxi.value,"ACQ Buffer Size","Sps") | |||
|
112 | self.limits.append(self.ACQ_BUF) | |||
|
113 | self.__libdwf.FDwfAnalogInFrequencyInfo(self.__hdwf, byref(Mind), byref(Maxd)) | |||
|
114 | self.ACQ_FREQ=self.limitRange(Mind.value,Maxd.value,"ACQ Frequency","Hz") | |||
|
115 | self.limits.append(self.ACQ_FREQ) | |||
|
116 | self.__libdwf.FDwfAnalogInChannelRangeSteps(self.__hdwf, byref(Steps), byref(StepsCount)) | |||
|
117 | self.ACQ_IN_RANGES=Steps[0:StepsCount.value] | |||
|
118 | self.__libdwf.FDwfAnalogOutNodeAmplitudeInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier, | |||
|
119 | byref(Mind), byref(Maxd)) | |||
|
120 | self.GEN_AMPL=self.limitRange(Mind.value,Maxd.value,"GEN Amplitude","V") | |||
|
121 | self.limits.append(self.GEN_AMPL) | |||
|
122 | self.__libdwf.FDwfAnalogOutNodeFrequencyInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier, | |||
|
123 | byref(Mind), byref(Maxd)) | |||
|
124 | self.GEN_FREQ=self.limitRange(Mind.value,Maxd.value,"GEN Frequency","Hz") | |||
|
125 | self.limits.append(self.GEN_FREQ) | |||
|
126 | self.__libdwf.FDwfAnalogOutNodeOffsetInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier, | |||
|
127 | byref(Mind), byref(Maxd)) | |||
|
128 | self.GEN_OFFSET=self.limitRange(Mind.value,Maxd.value,"GEN Offset","V") | |||
|
129 | self.limits.append(self.GEN_OFFSET) | |||
|
130 | self.__libdwf.FDwfAnalogOutNodeDataInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier, | |||
|
131 | byref(Mini), byref(Maxi)) | |||
|
132 | self.GEN_BUFF=self.limitRange(Mini.value,Maxi.value,"GEN Buffer size","Sps") | |||
|
133 | self.limits.append(self.GEN_BUFF) | |||
|
134 | ||||
|
135 | ||||
|
136 | def __conformParam(self,minVal,maxVal,val): | |||
|
137 | if val<minVal: | |||
|
138 | raise self.errors.get(1) | |||
|
139 | print("Force to "+str(minVal)) | |||
|
140 | return minVal | |||
|
141 | if val>maxVal: | |||
|
142 | raise self.errors.get(1) | |||
|
143 | print("Force to "+str(maxVal)) | |||
|
144 | return maxVal | |||
|
145 | return val | |||
|
146 | ||||
|
147 | def acqFreq(self, value): | |||
|
148 | return self.ACQ_FREQ.conform(value) | |||
|
149 | ||||
|
150 | def acqBufSize(self, value): | |||
|
151 | return self.ACQ_BUF.conform(value) | |||
|
152 | ||||
|
153 | def genFreq(self, value): | |||
|
154 | return self.GEN_FREQ.conform(value) | |||
|
155 | ||||
|
156 | def genAmplitude(self, value): | |||
|
157 | return self.GEN_AMPL.conform(value) | |||
|
158 | ||||
|
159 | def genOffset(self, value): | |||
|
160 | return self.GEN_OFFSET.conform(value) | |||
|
161 | ||||
|
162 | def genBuffSize(self, value): | |||
|
163 | return self.GEN_BUFF.conform(value) | |||
|
164 | ||||
|
165 | def printme(self): | |||
|
166 | for i in self.limits: | |||
|
167 | i.printme() | |||
|
168 | print("ACQ Input ranes: "+str(self.ACQ_IN_RANGES)) | |||
|
169 | ||||
|
170 | ||||
|
171 | class discovery(): | |||
|
172 | ||||
|
173 | errors = {0: RuntimeError("No card opened"), | |||
|
174 | 1: UserWarning("Parameter out of bound"), | |||
|
175 | } | |||
|
176 | def __init__(self,card=-1): | |||
|
177 | if sys.platform.startswith("win"): | |||
|
178 | self.__libdwf = cdll.dwf | |||
|
179 | elif sys.platform.startswith("darwin"): | |||
|
180 | self.__libdwf = cdll.LoadLibrary("libdwf.dylib") | |||
|
181 | else: | |||
|
182 | self.__libdwf = cdll.LoadLibrary("libdwf.so") | |||
|
183 | self.__opened = True | |||
|
184 | self.__hdwf = c_int() | |||
|
185 | self.__libdwf.FDwfDeviceOpen(c_int(card), byref(self.__hdwf)) | |||
|
186 | if self.__hdwf.value == nodev.value: | |||
|
187 | szerr = create_string_buffer(512) | |||
|
188 | self.__libdwf.FDwfGetLastErrorMsg(szerr) | |||
|
189 | print(szerr.value) | |||
|
190 | print("failed to open device") | |||
|
191 | self.__opened=False | |||
|
192 | self.__limits=discoveryLimits(self.__libdwf,self.__hdwf) | |||
|
193 | self.__limits.printme() | |||
|
194 | ||||
|
195 | @property | |||
|
196 | def opened(self): | |||
|
197 | return self.__opened | |||
|
198 | ||||
|
199 | ||||
|
200 | ############################################################# | |||
|
201 | # Power Supply | |||
|
202 | ############################################################# | |||
|
203 | def setPower(self,fiveVolt=1,minusFiveVolt=1,master=True): | |||
|
204 | if not self.__opened: | |||
|
205 | raise self.errors.get(0) | |||
|
206 | # enable positive supply | |||
|
207 | self.__libdwf.FDwfAnalogIOChannelNodeSet(self.__hdwf, 0, 0, c_double(fiveVolt)) | |||
|
208 | # enable negative supply | |||
|
209 | self.__libdwf.FDwfAnalogIOChannelNodeSet(self.__hdwf, 1, 0, c_double(minusFiveVolt)) | |||
|
210 | # master enable | |||
|
211 | return self.__libdwf.FDwfAnalogIOEnableSet(self.__hdwf, master) | |||
|
212 | ||||
|
213 | def getPower(self): | |||
|
214 | if not self.__opened: | |||
|
215 | raise self.errors.get(0) | |||
|
216 | supplyVoltage = c_double() | |||
|
217 | supplyCurrent = c_double() | |||
|
218 | IsEnabled = c_bool() | |||
|
219 | self.__libdwf.FDwfAnalogIOStatus(self.__hdwf) | |||
|
220 | self.__libdwf.FDwfAnalogIOChannelNodeStatus(self.__hdwf, c_int(3), c_int(0), byref(supplyVoltage)) | |||
|
221 | self.__libdwf.FDwfAnalogIOChannelNodeStatus(self.__hdwf, c_int(3), c_int(1), byref(supplyCurrent)) | |||
|
222 | self.__libdwf.FDwfAnalogIOEnableStatus(self.__hdwf, byref(IsEnabled)) | |||
|
223 | return [IsEnabled.value,supplyVoltage.value,supplyCurrent.value] | |||
|
224 | ||||
|
225 | ############################################################# | |||
|
226 | # AnalogIn | |||
|
227 | ############################################################# | |||
|
228 | def analogInRead(self,ch1=True,ch2=True,frequency=100000000,samplesCount=100,ch1range=5.0,ch2range=5.0,trigger=trigsrcNone): | |||
|
229 | if not self.__opened: | |||
|
230 | raise self.errors.get(0) | |||
|
231 | cnt=self.__limits.acqBufSize(samplesCount) | |||
|
232 | self.__libdwf.FDwfAnalogInFrequencySet(self.__hdwf, c_double(self.__limits.acqFreq(frequency))) | |||
|
233 | f=c_double() | |||
|
234 | self.__libdwf.FDwfAnalogInFrequencyGet(self.__hdwf, byref(f)) | |||
|
235 | frequency=f.value | |||
|
236 | self.__libdwf.FDwfAnalogInBufferSizeSet(self.__hdwf, c_int(cnt)) | |||
|
237 | self.__libdwf.FDwfAnalogInChannelEnableSet(self.__hdwf, c_int(0), c_bool(ch1)) | |||
|
238 | self.__libdwf.FDwfAnalogInChannelRangeSet(self.__hdwf, c_int(0), c_double(ch1range)) | |||
|
239 | self.__libdwf.FDwfAnalogInChannelEnableSet(self.__hdwf, c_int(1), c_bool(ch2)) | |||
|
240 | self.__libdwf.FDwfAnalogInChannelRangeSet(self.__hdwf, c_int(1), c_double(ch2range)) | |||
|
241 | self.setAnaloInTrigger(trigger) | |||
|
242 | self.__libdwf.FDwfAnalogInConfigure(self.__hdwf, c_bool(False), c_bool(True)) | |||
|
243 | status = c_byte() | |||
|
244 | while True: | |||
|
245 | self.__libdwf.FDwfAnalogInStatus(self.__hdwf, c_int(1), byref(status)) | |||
|
246 | if status.value == DwfStateDone.value : | |||
|
247 | break | |||
|
248 | time.sleep(0.1) | |||
|
249 | if ch1: | |||
|
250 | ch1data = (c_double*cnt)() | |||
|
251 | self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 0, ch1data, cnt) | |||
|
252 | if ch2: | |||
|
253 | ch2data = (c_double*cnt)() | |||
|
254 | self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 1, ch2data, cnt) | |||
|
255 | return [np.array([ch1data,ch2data]),frequency] | |||
|
256 | else: | |||
|
257 | return [np.array([ch1data]),frequency] | |||
|
258 | if ch2: | |||
|
259 | ch2data = (c_double*cnt)() | |||
|
260 | self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 1, ch2data, cnt) | |||
|
261 | return [np.array([ch2data]),frequency] | |||
|
262 | ||||
|
263 | ||||
|
264 | def setAnaloInTrigger(self,trigger=trigAuto,autoTimeout=0.0): | |||
|
265 | if not self.__opened: | |||
|
266 | raise self.errors.get(0) | |||
|
267 | if trigger == trigAuto: | |||
|
268 | self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigsrcDetectorAnalogIn) | |||
|
269 | self.__libdwf.FDwfAnalogInTriggerAutoTimeoutSet(self.__hdwf,c_double(autoTimeout)) | |||
|
270 | return | |||
|
271 | if trigger == trigNormal: | |||
|
272 | self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigsrcDetectorAnalogIn) | |||
|
273 | self.__libdwf.FDwfAnalogInTriggerAutoTimeoutSet(self.__hdwf,c_double(0.0)) | |||
|
274 | return | |||
|
275 | self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigger) | |||
|
276 | ||||
|
277 | ############################################################# | |||
|
278 | # AnalogOut | |||
|
279 | ############################################################# | |||
|
280 | def analogOutGen(self,frequency=1000, shape='Sine', channel=0, amplitude=1.0, offset=0.0): | |||
|
281 | self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(False)) | |||
|
282 | self.__libdwf.FDwfAnalogOutNodeEnableSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_bool(True)) | |||
|
283 | self.__libdwf.FDwfAnalogOutNodeFunctionSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_int(shapes.get(shape))) | |||
|
284 | self.__libdwf.FDwfAnalogOutNodeFrequencySet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genFreq(frequency))) | |||
|
285 | self.__libdwf.FDwfAnalogOutNodeAmplitudeSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genAmplitude(amplitude))) | |||
|
286 | self.__libdwf.FDwfAnalogOutNodeOffsetSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genOffset(offset))) | |||
|
287 | self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True)) | |||
|
288 | ||||
|
289 | def analogOutGenArbit(self,samplesBuffer ,repeatingFrequency=100, channel=0, amplitude=1.0, offset=0.0): | |||
|
290 | self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(False)) | |||
|
291 | cnt=self.__limits.genBuffSize(len(samplesBuffer)) | |||
|
292 | buf=(c_double*cnt)() | |||
|
293 | buf[:]=samplesBuffer[0:cnt] | |||
|
294 | repeatingFrequency = self.__limits.genFreq(repeatingFrequency*cnt)/cnt | |||
|
295 | self.__libdwf.FDwfAnalogOutNodeEnableSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_bool(True)) | |||
|
296 | self.__libdwf.FDwfAnalogOutNodeFunctionSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_int(shapes.get("Custom"))) | |||
|
297 | self.__libdwf.FDwfAnalogOutNodeFrequencySet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(repeatingFrequency)) | |||
|
298 | self.__libdwf.FDwfAnalogOutNodeAmplitudeSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genAmplitude(amplitude))) | |||
|
299 | self.__libdwf.FDwfAnalogOutNodeOffsetSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genOffset(offset))) | |||
|
300 | self.__libdwf.FDwfAnalogOutNodeDataSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, buf, c_int(cnt)) | |||
|
301 | self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True)) | |||
|
302 | ||||
|
303 | ||||
|
304 | def __del__(self): | |||
|
305 | if self.__opened: | |||
|
306 | self.__libdwf.FDwfDeviceClose(self.__hdwf) | |||
|
307 | ||||
|
308 | ||||
|
309 | ||||
|
310 | ||||
|
311 | if __name__ == '__main__': | |||
|
312 | print("open first dev") | |||
|
313 | test = discovery() | |||
|
314 | test.setPower() | |||
|
315 | for i in range(2): | |||
|
316 | time.sleep(0.2) | |||
|
317 | print(test.getPower()) | |||
|
318 | test.analogOutGen() | |||
|
319 | res=test.analogInRead(frequency=1000000,samplesCount=1000) | |||
|
320 | print(res) | |||
|
321 | plt.plot(range(len(res[0][0])),res[0][0]) | |||
|
322 | plt.plot(range(len(res[0][0])),res[0][1]) | |||
|
323 | plt.show() | |||
|
324 | test.temp() | |||
|
325 | # del test | |||
|
326 | quit() | |||
|
327 | ||||
|
328 | ||||
|
329 | ||||
|
330 | ||||
|
331 |
@@ -0,0 +1,44 | |||||
|
1 | #!/usr/bin/env python | |||
|
2 | #-*- coding: utf-8 -*- | |||
|
3 | """Simple python library to drive DLP-TEMP module from www.dlpdesign.com | |||
|
4 | """ | |||
|
5 | import time | |||
|
6 | import sys | |||
|
7 | import os | |||
|
8 | import matplotlib.pyplot as plt | |||
|
9 | import numpy as np | |||
|
10 | import serial | |||
|
11 | ||||
|
12 | __author__ = "Alexis Jeandet" | |||
|
13 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" | |||
|
14 | __credits__ = [] | |||
|
15 | __license__ = "GPLv2" | |||
|
16 | __version__ = "1.0.0" | |||
|
17 | __maintainer__ = "Alexis Jeandet" | |||
|
18 | __email__ = "alexis.jeandet@member.fsf.org" | |||
|
19 | __status__ = "Production" | |||
|
20 | ||||
|
21 | class dlp_temp(): | |||
|
22 | sensors = {0 : b'S', | |||
|
23 | 1 : b'T', | |||
|
24 | 2 : b'U', | |||
|
25 | } | |||
|
26 | def __init__(self,port): | |||
|
27 | self.i=0 | |||
|
28 | self.__port=serial.Serial(port,timeout=0.5) | |||
|
29 | ||||
|
30 | def ping(self): | |||
|
31 | self.__port.write(b"P") | |||
|
32 | return b'Q' == self.__port.read(1) | |||
|
33 | ||||
|
34 | def readSensor(self,index): | |||
|
35 | if index < 3: | |||
|
36 | self.__port.write(self.sensors.get(index)) | |||
|
37 | dat=self.__port.read(9) | |||
|
38 | test=( int(ord(dat[0])) + (int(ord(dat[1]))*256) ) | |||
|
39 | temp=float(test)*0.0625 | |||
|
40 | return temp #(temp-32.0)/1.8 | |||
|
41 | raise UserWarning("Parameter out of bound") | |||
|
42 | ||||
|
43 | if __name__ == '__main__': | |||
|
44 | print("") |
@@ -0,0 +1,128 | |||||
|
1 | #-*- coding: utf-8 -*- | |||
|
2 | #Copyright 2015 Alexis Jeandet | |||
|
3 | #This file is part of lppinstru. | |||
|
4 | ||||
|
5 | #lppinstru is free software: you can redistribute it and/or modify | |||
|
6 | #it under the terms of the GNU General Public License as published by | |||
|
7 | #the Free Software Foundation, either version 3 of the License, or | |||
|
8 | #(at your option) any later version. | |||
|
9 | ||||
|
10 | #pydiscovery is distributed in the hope that it will be useful, | |||
|
11 | #but WITHOUT ANY WARRANTY; without even the implied warranty of | |||
|
12 | #MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |||
|
13 | #GNU General Public License for more details. | |||
|
14 | ||||
|
15 | #You should have received a copy of the GNU General Public License | |||
|
16 | #along with pydiscovery. If not, see <http://www.gnu.org/licenses/>. | |||
|
17 | import time | |||
|
18 | import sys | |||
|
19 | import os | |||
|
20 | import matplotlib.pyplot as plt | |||
|
21 | import numpy as np | |||
|
22 | import serial | |||
|
23 | ||||
|
24 | class gpd_xxx(): | |||
|
25 | conf = {"GPD-3303S" : (2,0.0,30.0), | |||
|
26 | "GPD-3303" : (), | |||
|
27 | } | |||
|
28 | trackingMode = {"Independent" : '0', | |||
|
29 | "Series" : '1', | |||
|
30 | "Parallel" : '2', | |||
|
31 | } | |||
|
32 | trackingModeStat = {"01": "Independent", | |||
|
33 | "11" : "Series", | |||
|
34 | "10" : "Parallel", | |||
|
35 | } | |||
|
36 | def __init__(self,port): | |||
|
37 | self.i=0 | |||
|
38 | self.__port=serial.Serial(port,timeout=0.5) | |||
|
39 | ||||
|
40 | def idn(self): | |||
|
41 | self.__port.setTimeout(0.1) | |||
|
42 | self.__port.write(b"*IDN?\n") | |||
|
43 | return self.__port.readall() | |||
|
44 | ||||
|
45 | def setVoltage(self,index,tension): | |||
|
46 | if index < 2: | |||
|
47 | self.__port.write("VSET"+str(index+1)+":"+str(tension)+"\n") | |||
|
48 | else: | |||
|
49 | raise UserWarning("Parameter out of bound") | |||
|
50 | ||||
|
51 | def voltageSet(self,index): | |||
|
52 | if index < 2: | |||
|
53 | self.__port.setTimeout(0.1) | |||
|
54 | self.__port.write("VSET"+str(index+1)+"?\n") | |||
|
55 | V=self.__port.readall() | |||
|
56 | return float(V.split("V")[0]) | |||
|
57 | else: | |||
|
58 | raise UserWarning("Parameter out of bound") | |||
|
59 | ||||
|
60 | def voltage(self,index): | |||
|
61 | if index < 2: | |||
|
62 | self.__port.setTimeout(0.1) | |||
|
63 | self.__port.write("VOUT"+str(index+1)+"?\n") | |||
|
64 | V=self.__port.readall() | |||
|
65 | return float(V.split("V")[0]) | |||
|
66 | else: | |||
|
67 | raise UserWarning("Parameter out of bound") | |||
|
68 | ||||
|
69 | def setCurrentLimit(self,index,limit): | |||
|
70 | if index < 2: | |||
|
71 | self.__port.write("ISET"+str(index+1)+":"+str(limit)+"\n") | |||
|
72 | else: | |||
|
73 | raise UserWarning("Parameter out of bound") | |||
|
74 | ||||
|
75 | def currentLimit(self,index): | |||
|
76 | if index < 2: | |||
|
77 | self.__port.setTimeout(0.1) | |||
|
78 | self.__port.write("ISET"+str(index+1)+"?\n") | |||
|
79 | I = self.__port.readall() | |||
|
80 | return float(I.split("A")[0]) | |||
|
81 | else: | |||
|
82 | raise UserWarning("Parameter out of bound") | |||
|
83 | ||||
|
84 | def current(self,index): | |||
|
85 | if index < 2: | |||
|
86 | self.__port.setTimeout(0.1) | |||
|
87 | self.__port.write("IOUT"+str(index+1)+"?\n") | |||
|
88 | I = self.__port.readall() | |||
|
89 | return float(I.split("A")[0]) | |||
|
90 | else: | |||
|
91 | raise UserWarning("Parameter out of bound") | |||
|
92 | ||||
|
93 | def turnOn(self,on=True): | |||
|
94 | if on: | |||
|
95 | self.__port.write("OUT1\n") | |||
|
96 | else: | |||
|
97 | self.__port.write("OUT0\n") | |||
|
98 | ||||
|
99 | def setTracking(self,mode="Independent"): | |||
|
100 | self.__port.write("TRACK"+self.trackingMode.get(mode)+"\n") | |||
|
101 | ||||
|
102 | def setBeep(self,on=True): | |||
|
103 | if on: | |||
|
104 | self.__port.write("BEEP1\n") | |||
|
105 | else: | |||
|
106 | self.__port.write("BEEP0\n") | |||
|
107 | ||||
|
108 | def tracking(self): | |||
|
109 | self.__port.write("STATUS?\n") | |||
|
110 | self.__port.setTimeout(0.1) | |||
|
111 | STAT = self.__port.readall() | |||
|
112 | BITS = STAT.split(" ") | |||
|
113 | return self.trackingModeStat.get(''.join(BITS[2:4])) | |||
|
114 | ||||
|
115 | def save(self,mem=1): | |||
|
116 | if mem>=1 and mem<=4: | |||
|
117 | self.__port.write("SAV"+str(mem)+"\n") | |||
|
118 | else: | |||
|
119 | raise UserWarning("Parameter mem of bound 1-4") | |||
|
120 | ||||
|
121 | def recal(self,mem=1): | |||
|
122 | if mem>=1 and mem<=4: | |||
|
123 | self.__port.write("RCL"+str(mem)+"\n") | |||
|
124 | else: | |||
|
125 | raise UserWarning("Parameter mem of bound 1-4") | |||
|
126 | ||||
|
127 | if __name__ == '__main__': | |||
|
128 | print("") |
@@ -0,0 +1,71 | |||||
|
1 | #!/usr/bin/env python | |||
|
2 | #-*- coding: utf-8 -*- | |||
|
3 | """Simple python library to compute transfert functions | |||
|
4 | """ | |||
|
5 | import time | |||
|
6 | import sys | |||
|
7 | import os | |||
|
8 | import matplotlib.pyplot as plt | |||
|
9 | import numpy as np | |||
|
10 | from scipy import fftpack | |||
|
11 | ||||
|
12 | __author__ = "Alexis Jeandet" | |||
|
13 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" | |||
|
14 | __credits__ = [] | |||
|
15 | __license__ = "GPLv2" | |||
|
16 | __version__ = "1.0.0" | |||
|
17 | __maintainer__ = "Alexis Jeandet" | |||
|
18 | __email__ = "alexis.jeandet@member.fsf.org" | |||
|
19 | __status__ = "Production" | |||
|
20 | ||||
|
21 | ||||
|
22 | ||||
|
23 | def __parseFFT(FFTi,FFTo,signalFreq,samplingFreq): | |||
|
24 | index=signalFreq*len(FFTi)/samplingFreq | |||
|
25 | powI=np.abs(FFTi[index-4:index+4]) | |||
|
26 | i=np.argmax(powI)+index-4 | |||
|
27 | mod=np.abs(FFTo[i])/np.abs(FFTi[i]) | |||
|
28 | arg=np.angle(FFTo[i])-np.angle(FFTi[i]) | |||
|
29 | if arg<-np.pi: | |||
|
30 | arg = (np.pi*2)+arg | |||
|
31 | if arg>np.pi: | |||
|
32 | arg = (-np.pi*2)+arg | |||
|
33 | return [signalFreq,mod,arg] | |||
|
34 | ||||
|
35 | def __step(device,freq,offset=0.0,maxAmp=5.0,lastAmp=1.0): | |||
|
36 | device.analogOutGen(freq, shape='Sine', channel=0, amplitude=lastAmp, offset=offset) | |||
|
37 | samplesCount=8192 | |||
|
38 | if freq > 500000: | |||
|
39 | FS=freq*samplesCount/500.0 | |||
|
40 | elif freq > 100000: | |||
|
41 | FS=freq*samplesCount/50.0 | |||
|
42 | else: | |||
|
43 | FS=freq*samplesCount/10.0 | |||
|
44 | res=device.analogInRead(ch1=True,ch2=True,frequency=FS,samplesCount=samplesCount,ch1range=5.0,ch2range=5.0) | |||
|
45 | FFTi=fftpack.fft(res[0][0]) | |||
|
46 | FFTo=fftpack.fft(res[0][1]) | |||
|
47 | return __parseFFT(FFTi,FFTo,freq,res[1]) | |||
|
48 | ||||
|
49 | ||||
|
50 | def computeTF(device,startFreq=1.0,stopFreq=100.0,offset=0.0,maxAmp=5.0,nstep=100): | |||
|
51 | freq=np.zeros(nstep) | |||
|
52 | f=[] | |||
|
53 | mod=[] | |||
|
54 | arg=[] | |||
|
55 | for i in range(int(nstep)) : | |||
|
56 | freq[i]=startFreq*np.power(10,((np.log10(stopFreq/startFreq))*i/(nstep-1))) | |||
|
57 | lastAmp=0.1 | |||
|
58 | for i in range(len(freq)): | |||
|
59 | step=__step(device,freq[i],offset=offset,maxAmp=maxAmp,lastAmp=lastAmp) | |||
|
60 | f.append(step[0]) | |||
|
61 | mod.append(step[1]) | |||
|
62 | arg.append(step[2]) | |||
|
63 | return [f,mod,arg] | |||
|
64 | ||||
|
65 | ||||
|
66 | if __name__ == '__main__': | |||
|
67 | print("") | |||
|
68 | ||||
|
69 | ||||
|
70 | ||||
|
71 |
@@ -0,0 +1,91 | |||||
|
1 | %if 0%{?fedora} > 12 | |||
|
2 | %bcond_without python3 | |||
|
3 | %else | |||
|
4 | %bcond_with python3 | |||
|
5 | %endif | |||
|
6 | ||||
|
7 | ||||
|
8 | %global pypi_name lppinstru | |||
|
9 | ||||
|
10 | Name: python-%{pypi_name} | |||
|
11 | Version: 1.0.0 | |||
|
12 | Release: 1%{?dist} | |||
|
13 | Summary: LPP's instrumentation library | |||
|
14 | ||||
|
15 | License: Python | |||
|
16 | URL: http://www.lpp.fr | |||
|
17 | Source0: http://www.lpp.fr/%{pypi_name}/%{pypi_name}-%{version}.zip | |||
|
18 | BuildArch: noarch | |||
|
19 | ||||
|
20 | BuildRequires: python2-devel | |||
|
21 | BuildRequires: python-setuptools | |||
|
22 | BuildRequires: numpy | |||
|
23 | BuildRequires: python-matplotlib | |||
|
24 | BuildRequires: pyserial | |||
|
25 | BuildRequires: /usr/*/libdwf.so | |||
|
26 | ||||
|
27 | %if %{with python3} | |||
|
28 | BuildRequires: python3-devel | |||
|
29 | BuildRequires: python3-setuptools | |||
|
30 | BuildRequires: python3-numpy | |||
|
31 | BuildRequires: python3-matplotlib | |||
|
32 | BuildRequires: python3-pyserial | |||
|
33 | %endif | |||
|
34 | ||||
|
35 | %description | |||
|
36 | LPP's instrumentation library | |||
|
37 | ||||
|
38 | %if %{with python3} | |||
|
39 | %package -n python3-%{pypi_name} | |||
|
40 | Summary: Integer to Roman numerals converter | |||
|
41 | ||||
|
42 | %description -n python3-%{pypi_name} | |||
|
43 | Integer to Roman numerals converter | |||
|
44 | %endif | |||
|
45 | ||||
|
46 | %prep | |||
|
47 | %setup -q -n %{pypi_name}-%{version} | |||
|
48 | # Remove bundled egg-info | |||
|
49 | rm -rf %{pypi_name}.egg-info | |||
|
50 | ||||
|
51 | %if %{with python3} | |||
|
52 | rm -rf %{py3dir} | |||
|
53 | cp -a . %{py3dir} | |||
|
54 | %endif | |||
|
55 | ||||
|
56 | ||||
|
57 | %build | |||
|
58 | %{__python2} setup.py build | |||
|
59 | ||||
|
60 | %if %{with python3} | |||
|
61 | pushd %{py3dir} | |||
|
62 | %{__python3} setup.py build | |||
|
63 | popd | |||
|
64 | %endif | |||
|
65 | ||||
|
66 | ||||
|
67 | %install | |||
|
68 | %if %{with python3} | |||
|
69 | pushd %{py3dir} | |||
|
70 | %{__python3} setup.py install -O1 --skip-build --root %{buildroot} | |||
|
71 | popd | |||
|
72 | %endif | |||
|
73 | ||||
|
74 | %{__python2} setup.py install --skip-build --root %{buildroot} | |||
|
75 | ||||
|
76 | %files | |||
|
77 | %doc | |||
|
78 | ||||
|
79 | %{python2_sitelib}/%{pypi_name}* | |||
|
80 | ||||
|
81 | %if %{with python3} | |||
|
82 | %files -n python3-%{pypi_name} | |||
|
83 | %{python3_sitelib}/%{pypi_name}* | |||
|
84 | ||||
|
85 | %endif | |||
|
86 | ||||
|
87 | %changelog | |||
|
88 | * Mon Nov 16 2015 Alexis Jeandet - 1.0.0 | |||
|
89 | - First build | |||
|
90 | ||||
|
91 |
@@ -0,0 +1,26 | |||||
|
1 | # -*- coding: utf-8 - | |||
|
2 | # | |||
|
3 | # This file is part of gunicorn released under the MIT license. | |||
|
4 | # See the NOTICE for more information. | |||
|
5 | ||||
|
6 | import os | |||
|
7 | import sys | |||
|
8 | ||||
|
9 | from setuptools import setup, find_packages | |||
|
10 | ||||
|
11 | from lppinstru import __version__ | |||
|
12 | ||||
|
13 | setup( | |||
|
14 | name='lppinstru', | |||
|
15 | version=__version__, | |||
|
16 | platforms='GNU/Linux, Fedora', | |||
|
17 | description='LPP\'s instrumentation packages', | |||
|
18 | long_description="", | |||
|
19 | author='Alexis Jeandet', | |||
|
20 | author_email='alexis.jeandet@member.fsf.org', | |||
|
21 | license='GPLv2', | |||
|
22 | url='www.lpp.fr', | |||
|
23 | packages=find_packages(exclude=['examples', 'tests']), | |||
|
24 | libraries=[] | |||
|
25 | ) | |||
|
26 |
General Comments 0
You need to be logged in to leave comments.
Login now