##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » lppinstru
RSS
First init
Alexis Jeandet -
r0:86b0cfa567c2 default
parent child
Show More
Show file before | Show file after | Hide comments
1 NO CONTENT: new file 100644
NO CONTENT: new file 100644
Show file before | Show file after | Hide comments
@@ -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"
Show file before | Show file after | Hide comments
@@ -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
Show file before | Show file after | Hide comments
@@ -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("")
Show file before | Show file after | Hide comments
@@ -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("")
Show file before | Show file after | Hide comments
@@ -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
Show file before | Show file after | Hide comments
@@ -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
Show file before | Show file after | Hide comments
@@ -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