##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » lppinstru
RSS
Started USB-TMC devices....
Alexis Jeandet -
r1:8ccb7546abb5 default
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,24
1 #!/usr/bin/env python
2 #-*- coding: utf-8 -*-
3 """Simple python library to communicate with Agilent 34410A over USB-TMC.
4 """
5 import time
6 import sys
7 import os
8 import agilenttmc
9
10 __author__ = "Alexis Jeandet"
11 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
12 __credits__ = []
13 __license__ = "GPLv2"
14 __version__ = "1.0.0"
15 __maintainer__ = "Alexis Jeandet"
16 __email__ = "alexis.jeandet@member.fsf.org"
17 __status__ = "Development"
18
19 class Agilent3441xA(usbtmc.UsbTmc):
20 def __init__(self,ref,serial=""):
21 isnt=usbtmc.findInstrument(ref,serial)
22 if inst=="":
23 raise UserWarning("Can't find instrument "+ref)
24 self.UsbTmc.__init__(isnt)
Show file before | Show file after | Hide comments
@@ -0,0 +1,26
1 #!/usr/bin/env python
2 #-*- coding: utf-8 -*-
3 """Simple python library to communicate with Agilent 34410A over USB-TMC.
4 """
5 import time
6 import sys
7 import os
8 import agilenttmc
9
10 __author__ = "Alexis Jeandet"
11 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
12 __credits__ = []
13 __license__ = "GPLv2"
14 __version__ = "1.0.0"
15 __maintainer__ = "Alexis Jeandet"
16 __email__ = "alexis.jeandet@member.fsf.org"
17 __status__ = "Development"
18
19 "34410A"
20
21 class Agilent3441xA(agilentusbtmc.AgilentUsbTmc):
22 def __init__(self,serial=""):
23 isnt=usbtmc.findInstrument("3441[0-1]A",serial)
24 if inst=="":
25 raise UserWarning("Can't find instrument "+ref)
26 self.UsbTmc.__init__(isnt)
Show file before | Show file after | Hide comments
@@ -0,0 +1,24
1 #!/usr/bin/env python
2 #-*- coding: utf-8 -*-
3 """Common Agilent USB-TMC/SCPI traits.
4 """
5 import time
6 import sys
7 import os
8 import usbtmc
9
10 __author__ = "Alexis Jeandet"
11 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
12 __credits__ = []
13 __license__ = "GPLv2"
14 __version__ = "1.0.0"
15 __maintainer__ = "Alexis Jeandet"
16 __email__ = "alexis.jeandet@member.fsf.org"
17 __status__ = "Development"
18
19 class AgilentUsbTmc(usbtmc.UsbTmc):
20 def __init__(self,ref,serial=""):
21 isnt=usbtmc.findInstrument(ref,serial)
22 if inst=="":
23 raise UserWarning("Can't find instrument "+ref)
24 self.UsbTmc.__init__(isnt)
Show file before | Show file after | Hide comments
@@ -0,0 +1,55
1 #!/usr/bin/env python
2 #-*- coding: utf-8 -*-
3 """Simple python library to communicate over USB-TMC protocol with linux's
4 usbtmc module.
5 """
6 import time
7 import sys
8 import os
9 import glob
10 import re
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
22 def find_instrument(ref,serial=""):
23 instruments=glob.glob("/dev/usbtmc[0-9]")
24 p = re.compile(ref)
25 for instrument in instruments:
26 dev=UsbTmc(instrument)
27 idn=dev.idn().split(",")
28 if p.match(idn[1]):
29 if serial=="" or serial == idn[2]:
30 return instrument
31 return ""
32
33 class UsbTmc():
34 def __init__(self,dev):
35 self.__PATH__=dev
36 self.__FILE__ = os.open(dev, os.O_RDWR)
37 if self.__FILE__==-1:
38 raise UserWarning("can't open "+dev)
39 self.Manufacturer=""
40 self.Reference=""
41 self.Serial=""
42 self.Version=""
43
44 def write(self, command):
45 os.write(self.__FILE__, command);
46
47 def read(self, length = 4000):
48 return os.read(self.__FILE__, length)
49
50 def idn(self):
51 self.write("*IDN?")
52 return self.read(100)
53
54 def __str__(self):
55 return self.idn() +"\n"+ self.__PATH__
Show file before | Show file after | Hide comments
@@ -1,10 +1,10
1 1 #!/usr/bin/env python
2 2 #-*- coding: utf-8 -*-
3 3 __author__ = "Alexis Jeandet"
4 4 __copyright__ = "Copyright 2015, Laboratory of Plasma Physics"
5 5 __credits__ = []
6 6 __license__ = "GPLv2"
7 7 __version__ = "1.0.0"
8 8 __maintainer__ = "Alexis Jeandet"
9 9 __email__ = "alexis.jeandet@member.fsf.org"
10 __status__ = "Production"
10 __status__ = "Development"
Show file before | Show file after | Hide comments
@@ -1,331 +1,333
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():
74 class DiscoveryLimits():
75 75 class limitRange():
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 def printme(self):
92 print(self.name + ":\n Min="+str(self.Min)+" "+self.unit+",Max="+str(self.Max)+" "+self.unit)
91 def __str__(self):
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 def printme(self):
165 def __str__(self):
166 res=str()
166 167 for i in self.limits:
167 i.printme()
168 print("ACQ Input ranes: "+str(self.ACQ_IN_RANGES))
168 res+=i.__str__()+"\n"
169 res+="ACQ Input ranes: "+str(self.ACQ_IN_RANGES)
170 return res
169 171
170 172
171 class discovery():
173 class Discovery():
172 174
173 175 errors = {0: RuntimeError("No card opened"),
174 176 1: UserWarning("Parameter out of bound"),
175 177 }
176 178 def __init__(self,card=-1):
177 179 if sys.platform.startswith("win"):
178 180 self.__libdwf = cdll.dwf
179 181 elif sys.platform.startswith("darwin"):
180 182 self.__libdwf = cdll.LoadLibrary("libdwf.dylib")
181 183 else:
182 184 self.__libdwf = cdll.LoadLibrary("libdwf.so")
183 185 self.__opened = True
184 186 self.__hdwf = c_int()
185 187 self.__libdwf.FDwfDeviceOpen(c_int(card), byref(self.__hdwf))
186 188 if self.__hdwf.value == nodev.value:
187 189 szerr = create_string_buffer(512)
188 190 self.__libdwf.FDwfGetLastErrorMsg(szerr)
189 191 print(szerr.value)
190 192 print("failed to open device")
191 193 self.__opened=False
192 self.__limits=discoveryLimits(self.__libdwf,self.__hdwf)
193 self.__limits.printme()
194 self.__limits=DiscoveryLimits(self.__libdwf,self.__hdwf)
195 print(self.__limits)
194 196
195 197 @property
196 198 def opened(self):
197 199 return self.__opened
198 200
199 201
200 202 #############################################################
201 203 # Power Supply
202 204 #############################################################
203 def setPower(self,fiveVolt=1,minusFiveVolt=1,master=True):
205 def set_power(self,fiveVolt=1,minusFiveVolt=1,master=True):
204 206 if not self.__opened:
205 207 raise self.errors.get(0)
206 208 # enable positive supply
207 209 self.__libdwf.FDwfAnalogIOChannelNodeSet(self.__hdwf, 0, 0, c_double(fiveVolt))
208 210 # enable negative supply
209 211 self.__libdwf.FDwfAnalogIOChannelNodeSet(self.__hdwf, 1, 0, c_double(minusFiveVolt))
210 212 # master enable
211 213 return self.__libdwf.FDwfAnalogIOEnableSet(self.__hdwf, master)
212 214
213 def getPower(self):
215 def get_power(self):
214 216 if not self.__opened:
215 217 raise self.errors.get(0)
216 218 supplyVoltage = c_double()
217 219 supplyCurrent = c_double()
218 220 IsEnabled = c_bool()
219 221 self.__libdwf.FDwfAnalogIOStatus(self.__hdwf)
220 222 self.__libdwf.FDwfAnalogIOChannelNodeStatus(self.__hdwf, c_int(3), c_int(0), byref(supplyVoltage))
221 223 self.__libdwf.FDwfAnalogIOChannelNodeStatus(self.__hdwf, c_int(3), c_int(1), byref(supplyCurrent))
222 224 self.__libdwf.FDwfAnalogIOEnableStatus(self.__hdwf, byref(IsEnabled))
223 225 return [IsEnabled.value,supplyVoltage.value,supplyCurrent.value]
224 226
225 227 #############################################################
226 228 # AnalogIn
227 229 #############################################################
228 def analogInRead(self,ch1=True,ch2=True,frequency=100000000,samplesCount=100,ch1range=5.0,ch2range=5.0,trigger=trigsrcNone):
230 def analog_in_read(self,ch1=True,ch2=True,frequency=100000000,samplesCount=100,ch1range=5.0,ch2range=5.0,trigger=trigsrcNone):
229 231 if not self.__opened:
230 232 raise self.errors.get(0)
231 233 cnt=self.__limits.acqBufSize(samplesCount)
232 234 self.__libdwf.FDwfAnalogInFrequencySet(self.__hdwf, c_double(self.__limits.acqFreq(frequency)))
233 235 f=c_double()
234 236 self.__libdwf.FDwfAnalogInFrequencyGet(self.__hdwf, byref(f))
235 237 frequency=f.value
236 238 self.__libdwf.FDwfAnalogInBufferSizeSet(self.__hdwf, c_int(cnt))
237 239 self.__libdwf.FDwfAnalogInChannelEnableSet(self.__hdwf, c_int(0), c_bool(ch1))
238 240 self.__libdwf.FDwfAnalogInChannelRangeSet(self.__hdwf, c_int(0), c_double(ch1range))
239 241 self.__libdwf.FDwfAnalogInChannelEnableSet(self.__hdwf, c_int(1), c_bool(ch2))
240 242 self.__libdwf.FDwfAnalogInChannelRangeSet(self.__hdwf, c_int(1), c_double(ch2range))
241 self.setAnaloInTrigger(trigger)
243 self.set_analog_in_trigger(trigger)
242 244 self.__libdwf.FDwfAnalogInConfigure(self.__hdwf, c_bool(False), c_bool(True))
243 245 status = c_byte()
244 246 while True:
245 247 self.__libdwf.FDwfAnalogInStatus(self.__hdwf, c_int(1), byref(status))
246 248 if status.value == DwfStateDone.value :
247 249 break
248 250 time.sleep(0.1)
249 251 if ch1:
250 252 ch1data = (c_double*cnt)()
251 253 self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 0, ch1data, cnt)
252 254 if ch2:
253 255 ch2data = (c_double*cnt)()
254 256 self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 1, ch2data, cnt)
255 257 return [np.array([ch1data,ch2data]),frequency]
256 258 else:
257 259 return [np.array([ch1data]),frequency]
258 260 if ch2:
259 261 ch2data = (c_double*cnt)()
260 262 self.__libdwf.FDwfAnalogInStatusData(self.__hdwf, 1, ch2data, cnt)
261 263 return [np.array([ch2data]),frequency]
262 264
263 265
264 def setAnaloInTrigger(self,trigger=trigAuto,autoTimeout=0.0):
266 def set_analog_in_trigger(self,trigger=trigAuto,autoTimeout=0.0):
265 267 if not self.__opened:
266 268 raise self.errors.get(0)
267 269 if trigger == trigAuto:
268 270 self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigsrcDetectorAnalogIn)
269 271 self.__libdwf.FDwfAnalogInTriggerAutoTimeoutSet(self.__hdwf,c_double(autoTimeout))
270 272 return
271 273 if trigger == trigNormal:
272 274 self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigsrcDetectorAnalogIn)
273 275 self.__libdwf.FDwfAnalogInTriggerAutoTimeoutSet(self.__hdwf,c_double(0.0))
274 276 return
275 277 self.__libdwf.FDwfAnalogInTriggerSourceSet(self.__hdwf,trigger)
276 278
277 279 #############################################################
278 280 # AnalogOut
279 281 #############################################################
280 def analogOutGen(self,frequency=1000, shape='Sine', channel=0, amplitude=1.0, offset=0.0):
282 def analog_out_gen(self,frequency=1000, shape='Sine', channel=0, amplitude=1.0, offset=0.0):
281 283 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(False))
282 284 self.__libdwf.FDwfAnalogOutNodeEnableSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_bool(True))
283 285 self.__libdwf.FDwfAnalogOutNodeFunctionSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_int(shapes.get(shape)))
284 286 self.__libdwf.FDwfAnalogOutNodeFrequencySet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genFreq(frequency)))
285 287 self.__libdwf.FDwfAnalogOutNodeAmplitudeSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genAmplitude(amplitude)))
286 288 self.__libdwf.FDwfAnalogOutNodeOffsetSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genOffset(offset)))
287 289 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True))
288 290
289 def analogOutGenArbit(self,samplesBuffer ,repeatingFrequency=100, channel=0, amplitude=1.0, offset=0.0):
291 def analog_out_gen_arbit(self,samplesBuffer ,repeatingFrequency=100, channel=0, amplitude=1.0, offset=0.0):
290 292 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(False))
291 293 cnt=self.__limits.genBuffSize(len(samplesBuffer))
292 294 buf=(c_double*cnt)()
293 295 buf[:]=samplesBuffer[0:cnt]
294 296 repeatingFrequency = self.__limits.genFreq(repeatingFrequency*cnt)/cnt
295 297 self.__libdwf.FDwfAnalogOutNodeEnableSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_bool(True))
296 298 self.__libdwf.FDwfAnalogOutNodeFunctionSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_int(shapes.get("Custom")))
297 299 self.__libdwf.FDwfAnalogOutNodeFrequencySet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(repeatingFrequency))
298 300 self.__libdwf.FDwfAnalogOutNodeAmplitudeSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genAmplitude(amplitude)))
299 301 self.__libdwf.FDwfAnalogOutNodeOffsetSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, c_double(self.__limits.genOffset(offset)))
300 302 self.__libdwf.FDwfAnalogOutNodeDataSet(self.__hdwf, c_int(channel), AnalogOutNodeCarrier, buf, c_int(cnt))
301 303 self.__libdwf.FDwfAnalogOutConfigure(self.__hdwf, c_int(channel), c_bool(True))
302 304
303 305
304 306 def __del__(self):
305 307 if self.__opened:
306 308 self.__libdwf.FDwfDeviceClose(self.__hdwf)
307 309
308 310
309 311
310 312
311 313 if __name__ == '__main__':
312 314 print("open first dev")
313 test = discovery()
314 test.setPower()
315 test = Discovery()
316 test.set_power()
315 317 for i in range(2):
316 318 time.sleep(0.2)
317 print(test.getPower())
318 test.analogOutGen()
319 res=test.analogInRead(frequency=1000000,samplesCount=1000)
319 print(test.get_power())
320 test.analog_out_gen()
321 res=test.analog_in_read(frequency=1000000,samplesCount=1000)
320 322 print(res)
321 323 plt.plot(range(len(res[0][0])),res[0][0])
322 324 plt.plot(range(len(res[0][0])),res[0][1])
323 325 plt.show()
324 326 test.temp()
325 327 # del test
326 328 quit()
327 329
328 330
329 331
330 332
331 333
Show file before | Show file after | Hide comments
@@ -1,128 +1,126
1 #!/usr/bin/env python
1 2 #-*- 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/>.
3 """Simple python library to communicate with GW Instek GPD-Series power supplies.
4 """
17 5 import time
18 6 import sys
19 7 import os
20 8 import matplotlib.pyplot as plt
21 9 import numpy as np
22 10 import serial
23 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
24 22 class gpd_xxx():
25 23 conf = {"GPD-3303S" : (2,0.0,30.0),
26 24 "GPD-3303" : (),
27 25 }
28 26 trackingMode = {"Independent" : '0',
29 27 "Series" : '1',
30 28 "Parallel" : '2',
31 29 }
32 30 trackingModeStat = {"01": "Independent",
33 31 "11" : "Series",
34 32 "10" : "Parallel",
35 33 }
36 34 def __init__(self,port):
37 35 self.i=0
38 36 self.__port=serial.Serial(port,timeout=0.5)
39 37
40 38 def idn(self):
41 39 self.__port.setTimeout(0.1)
42 40 self.__port.write(b"*IDN?\n")
43 41 return self.__port.readall()
44 42
45 43 def setVoltage(self,index,tension):
46 44 if index < 2:
47 45 self.__port.write("VSET"+str(index+1)+":"+str(tension)+"\n")
48 46 else:
49 47 raise UserWarning("Parameter out of bound")
50 48
51 49 def voltageSet(self,index):
52 50 if index < 2:
53 51 self.__port.setTimeout(0.1)
54 52 self.__port.write("VSET"+str(index+1)+"?\n")
55 53 V=self.__port.readall()
56 54 return float(V.split("V")[0])
57 55 else:
58 56 raise UserWarning("Parameter out of bound")
59 57
60 58 def voltage(self,index):
61 59 if index < 2:
62 60 self.__port.setTimeout(0.1)
63 61 self.__port.write("VOUT"+str(index+1)+"?\n")
64 62 V=self.__port.readall()
65 63 return float(V.split("V")[0])
66 64 else:
67 65 raise UserWarning("Parameter out of bound")
68 66
69 67 def setCurrentLimit(self,index,limit):
70 68 if index < 2:
71 69 self.__port.write("ISET"+str(index+1)+":"+str(limit)+"\n")
72 70 else:
73 71 raise UserWarning("Parameter out of bound")
74 72
75 73 def currentLimit(self,index):
76 74 if index < 2:
77 75 self.__port.setTimeout(0.1)
78 76 self.__port.write("ISET"+str(index+1)+"?\n")
79 77 I = self.__port.readall()
80 78 return float(I.split("A")[0])
81 79 else:
82 80 raise UserWarning("Parameter out of bound")
83 81
84 82 def current(self,index):
85 83 if index < 2:
86 84 self.__port.setTimeout(0.1)
87 85 self.__port.write("IOUT"+str(index+1)+"?\n")
88 86 I = self.__port.readall()
89 87 return float(I.split("A")[0])
90 88 else:
91 89 raise UserWarning("Parameter out of bound")
92 90
93 91 def turnOn(self,on=True):
94 92 if on:
95 93 self.__port.write("OUT1\n")
96 94 else:
97 95 self.__port.write("OUT0\n")
98 96
99 97 def setTracking(self,mode="Independent"):
100 98 self.__port.write("TRACK"+self.trackingMode.get(mode)+"\n")
101 99
102 100 def setBeep(self,on=True):
103 101 if on:
104 102 self.__port.write("BEEP1\n")
105 103 else:
106 104 self.__port.write("BEEP0\n")
107 105
108 106 def tracking(self):
109 107 self.__port.write("STATUS?\n")
110 108 self.__port.setTimeout(0.1)
111 109 STAT = self.__port.readall()
112 110 BITS = STAT.split(" ")
113 111 return self.trackingModeStat.get(''.join(BITS[2:4]))
114 112
115 113 def save(self,mem=1):
116 114 if mem>=1 and mem<=4:
117 115 self.__port.write("SAV"+str(mem)+"\n")
118 116 else:
119 117 raise UserWarning("Parameter mem of bound 1-4")
120 118
121 119 def recal(self,mem=1):
122 120 if mem>=1 and mem<=4:
123 121 self.__port.write("RCL"+str(mem)+"\n")
124 122 else:
125 123 raise UserWarning("Parameter mem of bound 1-4")
126 124
127 125 if __name__ == '__main__':
128 126 print("")
Show file before | Show file after | Hide comments
@@ -1,71 +1,71
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 __status__ = "Production"
19 __status__ = "Development"
20 20
21 21
22 22
23 23 def __parseFFT(FFTi,FFTo,signalFreq,samplingFreq):
24 24 index=signalFreq*len(FFTi)/samplingFreq
25 25 powI=np.abs(FFTi[index-4:index+4])
26 26 i=np.argmax(powI)+index-4
27 27 mod=np.abs(FFTo[i])/np.abs(FFTi[i])
28 28 arg=np.angle(FFTo[i])-np.angle(FFTi[i])
29 29 if arg<-np.pi:
30 30 arg = (np.pi*2)+arg
31 31 if arg>np.pi:
32 32 arg = (-np.pi*2)+arg
33 33 return [signalFreq,mod,arg]
34 34
35 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)
36 device.analog_out_gen(freq, shape='Sine', channel=0, amplitude=lastAmp, offset=offset)
37 37 samplesCount=8192
38 38 if freq > 500000:
39 39 FS=freq*samplesCount/500.0
40 40 elif freq > 100000:
41 41 FS=freq*samplesCount/50.0
42 42 else:
43 43 FS=freq*samplesCount/10.0
44 res=device.analogInRead(ch1=True,ch2=True,frequency=FS,samplesCount=samplesCount,ch1range=5.0,ch2range=5.0)
44 res=device.analog_in_read(ch1=True,ch2=True,frequency=FS,samplesCount=samplesCount,ch1range=5.0,ch2range=5.0)
45 45 FFTi=fftpack.fft(res[0][0])
46 46 FFTo=fftpack.fft(res[0][1])
47 47 return __parseFFT(FFTi,FFTo,freq,res[1])
48 48
49 49
50 50 def computeTF(device,startFreq=1.0,stopFreq=100.0,offset=0.0,maxAmp=5.0,nstep=100):
51 51 freq=np.zeros(nstep)
52 52 f=[]
53 53 mod=[]
54 54 arg=[]
55 55 for i in range(int(nstep)) :
56 56 freq[i]=startFreq*np.power(10,((np.log10(stopFreq/startFreq))*i/(nstep-1)))
57 57 lastAmp=0.1
58 58 for i in range(len(freq)):
59 59 step=__step(device,freq[i],offset=offset,maxAmp=maxAmp,lastAmp=lastAmp)
60 60 f.append(step[0])
61 61 mod.append(step[1])
62 62 arg.append(step[2])
63 63 return [f,mod,arg]
64 64
65 65
66 66 if __name__ == '__main__':
67 67 print("")
68 68
69 69
70 70
71 71
General Comments 0
You need to be logged in to leave comments. Login now