##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » lppinstru
RSS
WIP
Alexis Jeandet -
r3:d444d1cc3fbf default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,73
1 #!/usr/bin/env python
2 #-*- coding: utf-8 -*-
3 """Simple python library to communicate with Prologix USB GPIB module.
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__ = "Development"
20
21 class UsbGpib(object):
22 modedic = {0:"DEVICE" ,
23 1:"CONTROLLER" ,}
24 revmodedic = {"DEVICE":"0" ,
25 "CONTROLLER":"1" ,}
26 def __init__(self,port,address=0):
27 self._port=serial.Serial(port,timeout=0.1)
28 self._address=address
29 self._mode=1
30 self.write("++ver")
31 self.version=self.read()
32 self.write("++auto 1")
33
34 def set_as_device(self):
35 self.write("++mode 0")
36 def set_as_controller(self):
37 self.write("++mode 1")
38
39 @property
40 def mode(self):
41 self.write("++mode")
42 self._mode= self.modedic[int(self.read())]
43 return self._mode
44
45 @mode.setter
46 def mode(self,new_mode):
47 self._mode=self.revmodedic[new_mode]
48 self.write("++mode %d" % self._mode)
49
50 @property
51 def address(self):
52 self._address=int(self.read("++addr"))
53 return self._address
54
55 @address.setter
56 def address(self,value):
57 self._address=int(value)
58 self.write("++addr %d" % self._address)
59
60 def write(self,command):
61 self._port.write(b"%s\n\r" % command)
62 self._port.flush()
63
64
65 def read(self,command="",GPIB=False):
66 if not command=="":
67 self.write(command)
68 if GPIB:
69 self.write("++read")
70 return self._port.readall()
71
72 def idn(self):
73 return self.read("*IDN?")
Show file before | Show file after | Hide comments
@@ -0,0 +1,2
1 syntax: glob
2 *.pyc
Show file before | Show file after | Hide comments
@@ -1,333 +1,344
1 1 #!/usr/bin/env python
2 2 #-*- coding: utf-8 -*-
3 3 """Simple python library to drive the analog discovery module from www.digilentinc.com
4 4 """
5 5
6 6 from ctypes import *
7 7 import time
8 8 import sys
9 9 import os
10 10 import matplotlib.pyplot as plt
11 11 import numpy as np
12 12
13 13 __author__ = "Alexis Jeandet"
14 14 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
15 15 __credits__ = []
16 16 __license__ = "GPLv2"
17 17 __version__ = "1.0.0"
18 18 __maintainer__ = "Alexis Jeandet"
19 19 __email__ = "alexis.jeandet@member.fsf.org"
20 20 __status__ = "Production"
21 21
22 22
23 23 nodev = c_int(0)
24 24 DwfStateDone = c_int(2)
25 25
26 26 DECIAnalogInChannelCount = c_int(1)
27 27 DECIAnalogOutChannelCount = c_int(2)
28 28 DECIAnalogIOChannelCount = c_int(3)
29 29 DECIDigitalInChannelCount = c_int(4)
30 30 DECIDigitalOutChannelCount = c_int(5)
31 31 DECIDigitalIOChannelCount = c_int(6)
32 32 DECIAnalogInBufferSize = c_int(7)
33 33 DECIAnalogOutBufferSize = c_int(8)
34 34 DECIDigitalInBufferSize = c_int(9)
35 35 DECIDigitalOutBufferSize = c_int(10)
36 36
37 37 trigsrcNone = c_byte(0)
38 38 trigsrcPC = c_byte(1)
39 39 trigsrcDetectorAnalogIn = c_byte(2)
40 40 trigsrcDetectorDigitalIn = c_byte(3)
41 41 trigsrcAnalogIn = c_byte(4)
42 42 trigsrcDigitalIn = c_byte(5)
43 43 trigsrcDigitalOut = c_byte(6)
44 44 trigsrcAnalogOut1 = c_byte(7)
45 45 trigsrcAnalogOut2 = c_byte(8)
46 46 trigsrcAnalogOut3 = c_byte(9)
47 47 trigsrcAnalogOut4 = c_byte(10)
48 48 trigsrcExternal1 = c_byte(11)
49 49 trigsrcExternal2 = c_byte(12)
50 50 trigsrcExternal3 = c_byte(13)
51 51 trigsrcExternal4 = c_byte(14)
52 52 trigAuto = c_byte(254)
53 53 trigNormal = c_byte(255)
54 54
55 55 AnalogOutNodeCarrier = c_int(0)
56 56 AnalogOutNodeFM = c_int(1)
57 57 AnalogOutNodeAM = c_int(2)
58 58
59 59
60 60 shapes = {'DC' : 0,
61 61 'Sine' : 1,
62 62 'Square' : 2,
63 63 'Triangle' : 3,
64 64 'RampUp' : 4,
65 65 'RampDown' : 5,
66 66 'Noise' : 6,
67 67 'Custom' : 30,
68 68 'Play' :31, }
69 69
70 70 closed=False
71 71 opened=True
72 72
73 73
74 class DiscoveryLimits():
75 class limitRange():
74 class DiscoveryLimits(object):
75 class limitRange(object):
76 76 def __init__(self,Min,Max,name="Unknow",unit=""):
77 77 self.Min = Min
78 78 self.Max = Max
79 79 self.name = name
80 80 self.unit = unit
81 81
82 82 def conform(self,value):
83 83 if value<self.Min:
84 84 raise UserWarning("Parameter "+self.name+" out of bound\nValue="+str(value)+"\nForce to "+str(self.Min))
85 85 return self.Min
86 86 if value>self.Max:
87 87 raise UserWarning("Parameter "+self.name+" out of bound\nValue="+str(value)+"\nForce to "+str(self.Max))
88 88 return self.Max
89 89 return value
90 90
91 91 def __str__(self):
92 92 return self.name + ":\n Min="+str(self.Min)+" "+self.unit+",Max="+str(self.Max)+" "+self.unit
93 93
94 94 errors = {0: RuntimeError("No card opened"),
95 95 1: UserWarning("Parameter out of bound"),
96 96 }
97 97 def __init__(self,libdwf,hdwf):
98 98 self.limits=[]
99 99 self.ACQ_IN_RANGES=[0.0]
100 100 if hdwf.value == nodev.value:
101 101 return
102 102 self.__hdwf=hdwf
103 103 self.__libdwf=libdwf
104 104 Mind=c_double()
105 105 Maxd=c_double()
106 106 Mini=c_int()
107 107 Maxi=c_int()
108 108 StepsCount=c_int()
109 109 Steps=(c_double*32)()
110 110 self.__libdwf.FDwfAnalogInBufferSizeInfo(self.__hdwf, byref(Mini), byref(Maxi))
111 111 self.ACQ_BUF=self.limitRange(Mini.value,Maxi.value,"ACQ Buffer Size","Sps")
112 112 self.limits.append(self.ACQ_BUF)
113 113 self.__libdwf.FDwfAnalogInFrequencyInfo(self.__hdwf, byref(Mind), byref(Maxd))
114 114 self.ACQ_FREQ=self.limitRange(Mind.value,Maxd.value,"ACQ Frequency","Hz")
115 115 self.limits.append(self.ACQ_FREQ)
116 116 self.__libdwf.FDwfAnalogInChannelRangeSteps(self.__hdwf, byref(Steps), byref(StepsCount))
117 117 self.ACQ_IN_RANGES=Steps[0:StepsCount.value]
118 118 self.__libdwf.FDwfAnalogOutNodeAmplitudeInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier,
119 119 byref(Mind), byref(Maxd))
120 120 self.GEN_AMPL=self.limitRange(Mind.value,Maxd.value,"GEN Amplitude","V")
121 121 self.limits.append(self.GEN_AMPL)
122 122 self.__libdwf.FDwfAnalogOutNodeFrequencyInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier,
123 123 byref(Mind), byref(Maxd))
124 124 self.GEN_FREQ=self.limitRange(Mind.value,Maxd.value,"GEN Frequency","Hz")
125 125 self.limits.append(self.GEN_FREQ)
126 126 self.__libdwf.FDwfAnalogOutNodeOffsetInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier,
127 127 byref(Mind), byref(Maxd))
128 128 self.GEN_OFFSET=self.limitRange(Mind.value,Maxd.value,"GEN Offset","V")
129 129 self.limits.append(self.GEN_OFFSET)
130 130 self.__libdwf.FDwfAnalogOutNodeDataInfo(self.__hdwf,c_int(0), AnalogOutNodeCarrier,
131 131 byref(Mini), byref(Maxi))
132 132 self.GEN_BUFF=self.limitRange(Mini.value,Maxi.value,"GEN Buffer size","Sps")
133 133 self.limits.append(self.GEN_BUFF)
134 134
135 135
136 136 def __conformParam(self,minVal,maxVal,val):
137 137 if val<minVal:
138 138 raise self.errors.get(1)
139 139 print("Force to "+str(minVal))
140 140 return minVal
141 141 if val>maxVal:
142 142 raise self.errors.get(1)
143 143 print("Force to "+str(maxVal))
144 144 return maxVal
145 145 return val
146 146
147 147 def acqFreq(self, value):
148 148 return self.ACQ_FREQ.conform(value)
149 149
150 150 def acqBufSize(self, value):
151 151 return self.ACQ_BUF.conform(value)
152 152
153 153 def genFreq(self, value):
154 154 return self.GEN_FREQ.conform(value)
155 155
156 156 def genAmplitude(self, value):
157 157 return self.GEN_AMPL.conform(value)
158 158
159 159 def genOffset(self, value):
160 160 return self.GEN_OFFSET.conform(value)
161 161
162 162 def genBuffSize(self, value):
163 163 return self.GEN_BUFF.conform(value)
164 164
165 165 def __str__(self):
166 166 res=str()
167 167 for i in self.limits:
168 168 res+=i.__str__()+"\n"
169 169 res+="ACQ Input ranes: "+str(self.ACQ_IN_RANGES)
170 170 return res
171 171
172 172
173 class Discovery():
173 class Discovery(object):
174 174
175 175 errors = {0: RuntimeError("No card opened"),
176 176 1: UserWarning("Parameter out of bound"),
177 177 }
178 178 def __init__(self,card=-1):
179 179 if sys.platform.startswith("win"):
180 180 self.__libdwf = cdll.dwf
181 181 elif sys.platform.startswith("darwin"):
182 182 self.__libdwf = cdll.LoadLibrary("libdwf.dylib")
183 183 else:
184 184 self.__libdwf = cdll.LoadLibrary("libdwf.so")
185 185 self.__opened = True
186 186 self.__hdwf = c_int()
187 187 self.__libdwf.FDwfDeviceOpen(c_int(card), byref(self.__hdwf))
188 188 if self.__hdwf.value == nodev.value:
189 189 szerr = create_string_buffer(512)
190 190 self.__libdwf.FDwfGetLastErrorMsg(szerr)
191 191 print(szerr.value)
192 192 print("failed to open device")
193 193 self.__opened=False
194 194 self.__limits=DiscoveryLimits(self.__libdwf,self.__hdwf)
195 195 print(self.__limits)
196 196
197 197 @property
198 198 def opened(self):
199 199 return self.__opened
200 200
201 @property
202 def max_sampling_freq(self):
203 return self.__limits.ACQ_FREQ.Max
204
205 @property
206 def min_sampling_freq(self):
207 return self.__limits.ACQ_FREQ.Min
208
209 @property
210 def max_sampling_buffer(self):
211 return self.__limits.ACQ_BUF.Max
201 212
202 213 #############################################################
203 214 # Power Supply
204 215 #############################################################
205 216 def set_power(self,fiveVolt=1,minusFiveVolt=1,master=True):
206 217 if not self.__opened:
207 218 raise self.errors.get(0)
208 219 # enable positive supply
209 220 self.__libdwf.FDwfAnalogIOChannelNodeSet(self.__hdwf, 0, 0, c_double(fiveVolt))
210 221 # enable negative supply
211 222 self.__libdwf.FDwfAnalogIOChannelNodeSet(self.__hdwf, 1, 0, c_double(minusFiveVolt))
212 223 # master enable
213 224 return self.__libdwf.FDwfAnalogIOEnableSet(self.__hdwf, master)
214 225
215 226 def get_power(self):
216 227 if not self.__opened:
217 228 raise self.errors.get(0)
218 229 supplyVoltage = c_double()
219 230 supplyCurrent = c_double()
220 231 IsEnabled = c_bool()
221 232 self.__libdwf.FDwfAnalogIOStatus(self.__hdwf)
222 233 self.__libdwf.FDwfAnalogIOChannelNodeStatus(self.__hdwf, c_int(3), c_int(0), byref(supplyVoltage))
223 234 self.__libdwf.FDwfAnalogIOChannelNodeStatus(self.__hdwf, c_int(3), c_int(1), byref(supplyCurrent))
224 235 self.__libdwf.FDwfAnalogIOEnableStatus(self.__hdwf, byref(IsEnabled))
225 236 return [IsEnabled.value,supplyVoltage.value,supplyCurrent.value]
226 237
227 238 #############################################################
228 239 # AnalogIn
229 240 #############################################################
230 241 def analog_in_read(self,ch1=True,ch2=True,frequency=100000000,samplesCount=100,ch1range=5.0,ch2range=5.0,trigger=trigsrcNone):
231 242 if not self.__opened:
232 243 raise self.errors.get(0)
233 244 cnt=self.__limits.acqBufSize(samplesCount)
234 245 self.__libdwf.FDwfAnalogInFrequencySet(self.__hdwf, c_double(self.__limits.acqFreq(frequency)))
235 246 f=c_double()
236 247 self.__libdwf.FDwfAnalogInFrequencyGet(self.__hdwf, byref(f))
237 248 frequency=f.value
238 249 self.__libdwf.FDwfAnalogInBufferSizeSet(self.__hdwf, c_int(cnt))
239 250 self.__libdwf.FDwfAnalogInChannelEnableSet(self.__hdwf, c_int(0), c_bool(ch1))
240 251 self.__libdwf.FDwfAnalogInChannelRangeSet(self.__hdwf, c_int(0), c_double(ch1range))
241 252 self.__libdwf.FDwfAnalogInChannelEnableSet(self.__hdwf, c_int(1), c_bool(ch2))
242 253 self.__libdwf.FDwfAnalogInChannelRangeSet(self.__hdwf, c_int(1), c_double(ch2range))
243 254 self.set_analog_in_trigger(trigger)
244 255 self.__libdwf.FDwfAnalogInConfigure(self.__hdwf, c_bool(False), c_bool(True))
245 256 status = c_byte()
246 257 while True:
247 258 self.__libdwf.FDwfAnalogInStatus(self.__hdwf, c_int(1), byref(status))
248 259 if status.value == DwfStateDone.value :
249 260 break
250 261 time.sleep(0.1)
251 262 if ch1:
252 263 ch1data = (c_double*cnt)()
253 264 self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 0, ch1data, cnt)
254 265 if ch2:
255 266 ch2data = (c_double*cnt)()
256 267 self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 1, ch2data, cnt)
257 268 return [np.array([ch1data,ch2data]),frequency]
258 269 else:
259 270 return [np.array([ch1data]),frequency]
260 271 if ch2:
261 272 ch2data = (c_double*cnt)()
262 273 self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 1, ch2data, cnt)
263 274 return [np.array([ch2data]),frequency]
264 275
265 276
266 277 def set_analog_in_trigger(self,trigger=trigAuto,autoTimeout=0.0):
267 278 if not self.__opened:
268 279 raise self.errors.get(0)
269 280 if trigger == trigAuto:
270 281 self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigsrcDetectorAnalogIn)
271 282 self.__libdwf.FDwfAnalogInTriggerAutoTimeoutSet(self.__hdwf,c_double(autoTimeout))
272 283 return
273 284 if trigger == trigNormal:
274 285 self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigsrcDetectorAnalogIn)
275 286 self.__libdwf.FDwfAnalogInTriggerAutoTimeoutSet(self.__hdwf,c_double(0.0))
276 287 return
277 288 self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigger)
278 289
279 290 #############################################################
280 291 # AnalogOut
281 292 #############################################################
282 293 def analog_out_gen(self,frequency=1000, shape='Sine', channel=0, amplitude=1.0, offset=0.0):
283 294 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(False))
284 295 self.__libdwf.FDwfAnalogOutNodeEnableSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_bool(True))
285 296 self.__libdwf.FDwfAnalogOutNodeFunctionSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_int(shapes.get(shape)))
286 297 self.__libdwf.FDwfAnalogOutNodeFrequencySet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genFreq(frequency)))
287 298 self.__libdwf.FDwfAnalogOutNodeAmplitudeSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genAmplitude(amplitude)))
288 299 self.__libdwf.FDwfAnalogOutNodeOffsetSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genOffset(offset)))
289 300 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True))
290 301
291 302 def analog_out_gen_arbit(self,samplesBuffer ,repeatingFrequency=100, channel=0, amplitude=1.0, offset=0.0):
292 303 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(False))
293 304 cnt=self.__limits.genBuffSize(len(samplesBuffer))
294 305 buf=(c_double*cnt)()
295 306 buf[:]=samplesBuffer[0:cnt]
296 307 repeatingFrequency = self.__limits.genFreq(repeatingFrequency*cnt)/cnt
297 308 self.__libdwf.FDwfAnalogOutNodeEnableSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_bool(True))
298 309 self.__libdwf.FDwfAnalogOutNodeFunctionSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_int(shapes.get("Custom")))
299 310 self.__libdwf.FDwfAnalogOutNodeFrequencySet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(repeatingFrequency))
300 311 self.__libdwf.FDwfAnalogOutNodeAmplitudeSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genAmplitude(amplitude)))
301 312 self.__libdwf.FDwfAnalogOutNodeOffsetSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genOffset(offset)))
302 313 self.__libdwf.FDwfAnalogOutNodeDataSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, buf, c_int(cnt))
303 314 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True))
304 315
305 316
306 317 def __del__(self):
307 318 if self.__opened:
308 319 self.__libdwf.FDwfDeviceClose(self.__hdwf)
309 320
310 321
311 322
312 323
313 324 if __name__ == '__main__':
314 325 print("open first dev")
315 326 test = Discovery()
316 327 test.set_power()
317 328 for i in range(2):
318 329 time.sleep(0.2)
319 330 print(test.get_power())
320 331 test.analog_out_gen()
321 332 res=test.analog_in_read(frequency=1000000,samplesCount=1000)
322 333 print(res)
323 334 plt.plot(range(len(res[0][0])),res[0][0])
324 335 plt.plot(range(len(res[0][0])),res[0][1])
325 336 plt.show()
326 337 test.temp()
327 338 # del test
328 339 quit()
329 340
330 341
331 342
332 343
333 344
Show file before | Show file after | Hide comments
@@ -1,44 +1,127
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("")
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(object):
22 sensors = {0 : b'S',
23 1 : b'T',
24 2 : b'U',
25 }
26 aninputs = {0 : b'A',
27 1 : b'B',
28 2 : b'C',
29 }
30 digitin= {0 : b'M',
31 1 : b'N',
32 2 : b'O',
33 }
34 digithigh= {0 : b'J',
35 1 : b'K',
36 2 : b'L',
37 }
38 digitlow= {0 : b'G',
39 1 : b'H',
40 2 : b'I',
41 }
42 def __init__(self,port):
43 self.i=0
44 self.__port=serial.Serial(port,timeout=0.5)
45
46 def ping(self):
47 self.__port.write(b"P")
48 return b'Q' == self.__port.read(1)
49
50 def read_sensor(self,index):
51 if index < 3:
52 self.__port.write(self.sensors.get(index))
53 dat=self.__port.read(9)
54 test=( int(ord(dat[0])) + (int(ord(dat[1]))*256) )
55 temp=float(test)*0.0625
56 return temp #(temp-32.0)/1.8
57 raise UserWarning("Parameter out of bound")
58
59 def read_analog_in(self,index):
60 if index < 3:
61 self.__port.write(self.aninputs.get(index))
62 dat=self.__port.read(2)
63 test=( int(ord(dat[0])) + (int(ord(dat[1]))*256) )
64 val=float(test)/512.0
65 return val
66 raise UserWarning("Parameter out of bound")
67
68 def digit_in(self,index):
69 if index < 3:
70 self.__port.write(self.digitin.get(index))
71 dat=self.__port.read(1)
72 return dat
73 raise UserWarning("Parameter out of bound")
74
75 def digit_out(self,index,val):
76 if index < 3:
77 if val:
78 self.__port.write(self.digithigh.get(index))
79 else:
80 self.__port.write(self.digitlow.get(index))
81 raise UserWarning("Parameter out of bound")
82
83 @Property
84 def sensor1(self):
85 return read_sensor(0)
86
87 @Property
88 def sensor2(self):
89 return read_sensor(1)
90
91 @Property
92 def sensor3(self):
93 return read_sensor(2)
94
95 @Property
96 def AN1(self):
97 return read_analog_in(0)
98 @Property
99 def AN2(self):
100 return read_analog_in(1)
101 @Property
102 def AN3(self):
103 return read_analog_in(2)
104
105 @Property
106 def GP2(self):
107 return self.digit_in(0)
108 @GP2.setter
109 def GP2(self,value):
110 return self.digit_out(0,val)
111
112 @Property
113 def GP0(self):
114 return self.digit_in(1)
115 @GP0.setter
116 def GP0(self,value):
117 return self.digit_out(1,val)
118
119 @Property
120 def GP4(self):
121 return self.digit_in(2)
122 @GP4.setter
123 def GP4(self,value):
124 return self.digit_out(2,val)
125
126 if __name__ == '__main__':
127 print("")
Show file before | Show file after | Hide comments
@@ -1,126 +1,126
1 1 #!/usr/bin/env python
2 2 #-*- coding: utf-8 -*-
3 3 """Simple python library to communicate with GW Instek GPD-Series power supplies.
4 4 """
5 5 import time
6 6 import sys
7 7 import os
8 8 import matplotlib.pyplot as plt
9 9 import numpy as np
10 10 import serial
11 11
12 12 __author__ = "Alexis Jeandet"
13 13 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
14 14 __credits__ = []
15 15 __license__ = "GPLv2"
16 16 __version__ = "1.0.0"
17 17 __maintainer__ = "Alexis Jeandet"
18 18 __email__ = "alexis.jeandet@member.fsf.org"
19 19 __status__ = "Development"
20 20
21 21
22 class gpd_xxx():
22 class gpd_xxx(object):
23 23 conf = {"GPD-3303S" : (2,0.0,30.0),
24 24 "GPD-3303" : (),
25 25 }
26 26 trackingMode = {"Independent" : '0',
27 27 "Series" : '1',
28 28 "Parallel" : '2',
29 29 }
30 30 trackingModeStat = {"01": "Independent",
31 31 "11" : "Series",
32 32 "10" : "Parallel",
33 33 }
34 34 def __init__(self,port):
35 35 self.i=0
36 36 self.__port=serial.Serial(port,timeout=0.5)
37 37
38 38 def idn(self):
39 39 self.__port.setTimeout(0.1)
40 40 self.__port.write(b"*IDN?\n")
41 41 return self.__port.readall()
42 42
43 43 def setVoltage(self,index,tension):
44 44 if index < 2:
45 45 self.__port.write("VSET"+str(index+1)+":"+str(tension)+"\n")
46 46 else:
47 47 raise UserWarning("Parameter out of bound")
48 48
49 49 def voltageSet(self,index):
50 50 if index < 2:
51 51 self.__port.setTimeout(0.1)
52 52 self.__port.write("VSET"+str(index+1)+"?\n")
53 53 V=self.__port.readall()
54 54 return float(V.split("V")[0])
55 55 else:
56 56 raise UserWarning("Parameter out of bound")
57 57
58 58 def voltage(self,index):
59 59 if index < 2:
60 60 self.__port.setTimeout(0.1)
61 61 self.__port.write("VOUT"+str(index+1)+"?\n")
62 62 V=self.__port.readall()
63 63 return float(V.split("V")[0])
64 64 else:
65 65 raise UserWarning("Parameter out of bound")
66 66
67 67 def setCurrentLimit(self,index,limit):
68 68 if index < 2:
69 69 self.__port.write("ISET"+str(index+1)+":"+str(limit)+"\n")
70 70 else:
71 71 raise UserWarning("Parameter out of bound")
72 72
73 73 def currentLimit(self,index):
74 74 if index < 2:
75 75 self.__port.setTimeout(0.1)
76 76 self.__port.write("ISET"+str(index+1)+"?\n")
77 77 I = self.__port.readall()
78 78 return float(I.split("A")[0])
79 79 else:
80 80 raise UserWarning("Parameter out of bound")
81 81
82 82 def current(self,index):
83 83 if index < 2:
84 84 self.__port.setTimeout(0.1)
85 85 self.__port.write("IOUT"+str(index+1)+"?\n")
86 86 I = self.__port.readall()
87 87 return float(I.split("A")[0])
88 88 else:
89 89 raise UserWarning("Parameter out of bound")
90 90
91 91 def turnOn(self,on=True):
92 92 if on:
93 93 self.__port.write("OUT1\n")
94 94 else:
95 95 self.__port.write("OUT0\n")
96 96
97 97 def setTracking(self,mode="Independent"):
98 98 self.__port.write("TRACK"+self.trackingMode.get(mode)+"\n")
99 99
100 100 def setBeep(self,on=True):
101 101 if on:
102 102 self.__port.write("BEEP1\n")
103 103 else:
104 104 self.__port.write("BEEP0\n")
105 105
106 106 def tracking(self):
107 107 self.__port.write("STATUS?\n")
108 108 self.__port.setTimeout(0.1)
109 109 STAT = self.__port.readall()
110 110 BITS = STAT.split(" ")
111 111 return self.trackingModeStat.get(''.join(BITS[2:4]))
112 112
113 113 def save(self,mem=1):
114 114 if mem>=1 and mem<=4:
115 115 self.__port.write("SAV"+str(mem)+"\n")
116 116 else:
117 117 raise UserWarning("Parameter mem of bound 1-4")
118 118
119 119 def recal(self,mem=1):
120 120 if mem>=1 and mem<=4:
121 121 self.__port.write("RCL"+str(mem)+"\n")
122 122 else:
123 123 raise UserWarning("Parameter mem of bound 1-4")
124 124
125 125 if __name__ == '__main__':
126 126 print("")
Show file before | Show file after | Hide comments
@@ -1,71 +1,79
1 1 #!/usr/bin/env python
2 2 #-*- coding: utf-8 -*-
3 3 """Simple python library to compute transfert functions
4 4 """
5 5 import time
6 6 import sys
7 7 import os
8 8 import matplotlib.pyplot as plt
9 9 import numpy as np
10 10 from scipy import fftpack
11 11
12 12 __author__ = "Alexis Jeandet"
13 13 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
14 14 __credits__ = []
15 15 __license__ = "GPLv2"
16 16 __version__ = "1.0.0"
17 17 __maintainer__ = "Alexis Jeandet"
18 18 __email__ = "alexis.jeandet@member.fsf.org"
19 19 __status__ = "Development"
20 20
21 21
22
23 22 def __parseFFT(FFTi,FFTo,signalFreq,samplingFreq):
24 23 index=signalFreq*len(FFTi)/samplingFreq
25 powI=np.abs(FFTi[index-4:index+4])
26 i=np.argmax(powI)+index-4
24 powI=np.abs(FFTi[int(index-1):int(index+1)])
25 i=int(np.argmax(powI)+index-1)
27 26 mod=np.abs(FFTo[i])/np.abs(FFTi[i])
28 27 arg=np.angle(FFTo[i])-np.angle(FFTi[i])
29 28 if arg<-np.pi:
30 29 arg = (np.pi*2)+arg
31 30 if arg>np.pi:
32 31 arg = (-np.pi*2)+arg
33 32 return [signalFreq,mod,arg]
34 33
34 def __compute_params(device,freq):
35 Periods=5
36 Fs=(freq*device.max_sampling_buffer)/Periods
37 if Fs < device.min_sampling_freq :
38 return [device.min_sampling_freq,device.max_sampling_buffer]
39 while Fs > (0.98*device.max_sampling_freq) :
40 Periods=Periods+1
41 Fs=(freq*device.max_sampling_buffer)/Periods
42 return [Fs,device.max_sampling_buffer]
43
35 44 def __step(device,freq,offset=0.0,maxAmp=5.0,lastAmp=1.0):
36 45 device.analog_out_gen(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.analog_in_read(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])
46 params=__compute_params(device,freq)
47 res=device.analog_in_read(ch1=True,ch2=True,frequency=params[0],samplesCount=params[1],ch1range=5.0,ch2range=5.0)
48 meanI=np.mean(res[0][0])
49 meanO=np.mean(res[0][1])
50 FFTi=fftpack.fft((res[0][0]-meanI)*np.hamming(len(res[0][0])))
51 FFTo=fftpack.fft((res[0][1]-meanO)*np.hamming(len(res[0][1])))
47 52 return __parseFFT(FFTi,FFTo,freq,res[1])
48 53
54 def generateLogFreq(startFreq=1.0,stopFreq=100.0,nstep=100):
55 freq=np.zeros(nstep)
56 for i in range(int(nstep)) :
57 freq[i]=startFreq*np.power(10,((np.log10(stopFreq/startFreq))*i/(nstep-1)))
58 return freq
49 59
50 60 def computeTF(device,startFreq=1.0,stopFreq=100.0,offset=0.0,maxAmp=5.0,nstep=100):
51 freq=np.zeros(nstep)
61 freqs=generateLogFreq(startFreq,stopFreq,nstep)
52 62 f=[]
53 63 mod=[]
54 64 arg=[]
55 for i in range(int(nstep)) :
56 freq[i]=startFreq*np.power(10,((np.log10(stopFreq/startFreq))*i/(nstep-1)))
57 65 lastAmp=0.1
58 for i in range(len(freq)):
59 step=__step(device,freq[i],offset=offset,maxAmp=maxAmp,lastAmp=lastAmp)
66 for freq in freqs:
67 step=__step(device,freq,offset=offset,maxAmp=maxAmp,lastAmp=lastAmp)
60 68 f.append(step[0])
61 69 mod.append(step[1])
62 70 arg.append(step[2])
63 71 return [f,mod,arg]
64 72
65 73
66 74 if __name__ == '__main__':
67 75 print("")
68 76
69 77
70 78
71 79
Show file before | Show file after | Hide comments
@@ -1,55 +1,55
1 1 #!/usr/bin/env python
2 2 #-*- coding: utf-8 -*-
3 3 """Simple python library to communicate over USB-TMC protocol with linux's
4 4 usbtmc module.
5 5 """
6 6 import time
7 7 import sys
8 8 import os
9 9 import glob
10 10 import re
11 11
12 12 __author__ = "Alexis Jeandet"
13 13 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
14 14 __credits__ = []
15 15 __license__ = "GPLv2"
16 16 __version__ = "1.0.0"
17 17 __maintainer__ = "Alexis Jeandet"
18 18 __email__ = "alexis.jeandet@member.fsf.org"
19 19 __status__ = "Development"
20 20
21 21
22 22 def find_instrument(ref,serial=""):
23 23 instruments=glob.glob("/dev/usbtmc[0-9]")
24 24 p = re.compile(ref)
25 25 for instrument in instruments:
26 26 dev=UsbTmc(instrument)
27 27 idn=dev.idn().split(",")
28 28 if p.match(idn[1]):
29 29 if serial=="" or serial == idn[2]:
30 30 return instrument
31 31 return ""
32 32
33 class UsbTmc():
33 class UsbTmc(object):
34 34 def __init__(self,dev):
35 35 self.__PATH__=dev
36 36 self.__FILE__ = os.open(dev, os.O_RDWR)
37 37 if self.__FILE__==-1:
38 38 raise UserWarning("can't open "+dev)
39 39 self.Manufacturer=""
40 40 self.Reference=""
41 41 self.Serial=""
42 42 self.Version=""
43 43
44 44 def write(self, command):
45 45 os.write(self.__FILE__, command);
46 46
47 47 def read(self, length = 4000):
48 48 return os.read(self.__FILE__, length)
49 49
50 50 def idn(self):
51 51 self.write("*IDN?")
52 52 return self.read(100)
53 53
54 54 def __str__(self):
55 55 return self.idn() +"\n"+ self.__PATH__
General Comments 0
You need to be logged in to leave comments. Login now