@@ -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?") |
@@ -71,8 +71,8 closed=False | |||||
71 | opened=True |
|
71 | opened=True | |
72 |
|
72 | |||
73 |
|
73 | |||
74 | class DiscoveryLimits(): |
|
74 | class DiscoveryLimits(object): | |
75 | class limitRange(): |
|
75 | class limitRange(object): | |
76 | def __init__(self,Min,Max,name="Unknow",unit=""): |
|
76 | def __init__(self,Min,Max,name="Unknow",unit=""): | |
77 | self.Min = Min |
|
77 | self.Min = Min | |
78 | self.Max = Max |
|
78 | self.Max = Max | |
@@ -170,7 +170,7 byref(Mini), byref(Maxi)) | |||||
170 | return res |
|
170 | return res | |
171 |
|
171 | |||
172 |
|
172 | |||
173 | class Discovery(): |
|
173 | class Discovery(object): | |
174 |
|
174 | |||
175 | errors = {0: RuntimeError("No card opened"), |
|
175 | errors = {0: RuntimeError("No card opened"), | |
176 | 1: UserWarning("Parameter out of bound"), |
|
176 | 1: UserWarning("Parameter out of bound"), | |
@@ -198,6 +198,17 class Discovery(): | |||||
198 | def opened(self): |
|
198 | def opened(self): | |
199 | return self.__opened |
|
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 | # Power Supply |
|
214 | # Power Supply |
@@ -1,44 +1,127 | |||||
1 | #!/usr/bin/env python |
|
1 | #!/usr/bin/env python | |
2 | #-*- coding: utf-8 -*- |
|
2 | #-*- coding: utf-8 -*- | |
3 | """Simple python library to drive DLP-TEMP module from www.dlpdesign.com |
|
3 | """Simple python library to drive DLP-TEMP module from www.dlpdesign.com | |
4 | """ |
|
4 | """ | |
5 | import time |
|
5 | import time | |
6 | import sys |
|
6 | import sys | |
7 | import os |
|
7 | import os | |
8 | import matplotlib.pyplot as plt |
|
8 | import matplotlib.pyplot as plt | |
9 | import numpy as np |
|
9 | import numpy as np | |
10 | import serial |
|
10 | import serial | |
11 |
|
11 | |||
12 | __author__ = "Alexis Jeandet" |
|
12 | __author__ = "Alexis Jeandet" | |
13 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" |
|
13 | __copyright__ = "Copyright 2015, Laboratory of Plasma Physics" | |
14 | __credits__ = [] |
|
14 | __credits__ = [] | |
15 | __license__ = "GPLv2" |
|
15 | __license__ = "GPLv2" | |
16 | __version__ = "1.0.0" |
|
16 | __version__ = "1.0.0" | |
17 | __maintainer__ = "Alexis Jeandet" |
|
17 | __maintainer__ = "Alexis Jeandet" | |
18 | __email__ = "alexis.jeandet@member.fsf.org" |
|
18 | __email__ = "alexis.jeandet@member.fsf.org" | |
19 | __status__ = "Production" |
|
19 | __status__ = "Production" | |
20 |
|
20 | |||
21 | class dlp_temp(): |
|
21 | class dlp_temp(object): | |
22 | sensors = {0 : b'S', |
|
22 | sensors = {0 : b'S', | |
23 | 1 : b'T', |
|
23 | 1 : b'T', | |
24 | 2 : b'U', |
|
24 | 2 : b'U', | |
25 | } |
|
25 | } | |
26 | def __init__(self,port): |
|
26 | aninputs = {0 : b'A', | |
27 | self.i=0 |
|
27 | 1 : b'B', | |
28 | self.__port=serial.Serial(port,timeout=0.5) |
|
28 | 2 : b'C', | |
29 |
|
29 | } | ||
30 | def ping(self): |
|
30 | digitin= {0 : b'M', | |
31 | self.__port.write(b"P") |
|
31 | 1 : b'N', | |
32 | return b'Q' == self.__port.read(1) |
|
32 | 2 : b'O', | |
33 |
|
33 | } | ||
34 | def readSensor(self,index): |
|
34 | digithigh= {0 : b'J', | |
35 | if index < 3: |
|
35 | 1 : b'K', | |
36 | self.__port.write(self.sensors.get(index)) |
|
36 | 2 : b'L', | |
37 | dat=self.__port.read(9) |
|
37 | } | |
38 | test=( int(ord(dat[0])) + (int(ord(dat[1]))*256) ) |
|
38 | digitlow= {0 : b'G', | |
39 | temp=float(test)*0.0625 |
|
39 | 1 : b'H', | |
40 | return temp #(temp-32.0)/1.8 |
|
40 | 2 : b'I', | |
41 | raise UserWarning("Parameter out of bound") |
|
41 | } | |
42 |
|
42 | def __init__(self,port): | ||
43 | if __name__ == '__main__': |
|
43 | self.i=0 | |
44 | print("") |
|
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("") |
@@ -19,7 +19,7 import serial | |||||
19 | __status__ = "Development" |
|
19 | __status__ = "Development" | |
20 |
|
20 | |||
21 |
|
21 | |||
22 | class gpd_xxx(): |
|
22 | class gpd_xxx(object): | |
23 | conf = {"GPD-3303S" : (2,0.0,30.0), |
|
23 | conf = {"GPD-3303S" : (2,0.0,30.0), | |
24 | "GPD-3303" : (), |
|
24 | "GPD-3303" : (), | |
25 | } |
|
25 | } |
@@ -19,11 +19,10 from scipy import fftpack | |||||
19 | __status__ = "Development" |
|
19 | __status__ = "Development" | |
20 |
|
20 | |||
21 |
|
21 | |||
22 |
|
||||
23 | def __parseFFT(FFTi,FFTo,signalFreq,samplingFreq): |
|
22 | def __parseFFT(FFTi,FFTo,signalFreq,samplingFreq): | |
24 | index=signalFreq*len(FFTi)/samplingFreq |
|
23 | index=signalFreq*len(FFTi)/samplingFreq | |
25 |
powI=np.abs(FFTi[index- |
|
24 | powI=np.abs(FFTi[int(index-1):int(index+1)]) | |
26 |
i=np.argmax(powI)+index- |
|
25 | i=int(np.argmax(powI)+index-1) | |
27 | mod=np.abs(FFTo[i])/np.abs(FFTi[i]) |
|
26 | mod=np.abs(FFTo[i])/np.abs(FFTi[i]) | |
28 | arg=np.angle(FFTo[i])-np.angle(FFTi[i]) |
|
27 | arg=np.angle(FFTo[i])-np.angle(FFTi[i]) | |
29 | if arg<-np.pi: |
|
28 | if arg<-np.pi: | |
@@ -32,31 +31,40 def __parseFFT(FFTi,FFTo,signalFreq,samp | |||||
32 | arg = (-np.pi*2)+arg |
|
31 | arg = (-np.pi*2)+arg | |
33 | return [signalFreq,mod,arg] |
|
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 | def __step(device,freq,offset=0.0,maxAmp=5.0,lastAmp=1.0): |
|
44 | def __step(device,freq,offset=0.0,maxAmp=5.0,lastAmp=1.0): | |
36 | device.analog_out_gen(freq, shape='Sine', channel=0, amplitude=lastAmp, offset=offset) |
|
45 | device.analog_out_gen(freq, shape='Sine', channel=0, amplitude=lastAmp, offset=offset) | |
37 | samplesCount=8192 |
|
46 | params=__compute_params(device,freq) | |
38 | if freq > 500000: |
|
47 | res=device.analog_in_read(ch1=True,ch2=True,frequency=params[0],samplesCount=params[1],ch1range=5.0,ch2range=5.0) | |
39 | FS=freq*samplesCount/500.0 |
|
48 | meanI=np.mean(res[0][0]) | |
40 | elif freq > 100000: |
|
49 | meanO=np.mean(res[0][1]) | |
41 | FS=freq*samplesCount/50.0 |
|
50 | FFTi=fftpack.fft((res[0][0]-meanI)*np.hamming(len(res[0][0]))) | |
42 | else: |
|
51 | FFTo=fftpack.fft((res[0][1]-meanO)*np.hamming(len(res[0][1]))) | |
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]) |
|
|||
47 | return __parseFFT(FFTi,FFTo,freq,res[1]) |
|
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 | def computeTF(device,startFreq=1.0,stopFreq=100.0,offset=0.0,maxAmp=5.0,nstep=100): |
|
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 | f=[] |
|
62 | f=[] | |
53 | mod=[] |
|
63 | mod=[] | |
54 | arg=[] |
|
64 | 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 |
|
65 | lastAmp=0.1 | |
58 |
for |
|
66 | for freq in freqs: | |
59 |
step=__step(device,freq |
|
67 | step=__step(device,freq,offset=offset,maxAmp=maxAmp,lastAmp=lastAmp) | |
60 | f.append(step[0]) |
|
68 | f.append(step[0]) | |
61 | mod.append(step[1]) |
|
69 | mod.append(step[1]) | |
62 | arg.append(step[2]) |
|
70 | arg.append(step[2]) |
@@ -30,7 +30,7 def find_instrument(ref,serial=""): | |||||
30 | return instrument |
|
30 | return instrument | |
31 | return "" |
|
31 | return "" | |
32 |
|
32 | |||
33 | class UsbTmc(): |
|
33 | class UsbTmc(object): | |
34 | def __init__(self,dev): |
|
34 | def __init__(self,dev): | |
35 | self.__PATH__=dev |
|
35 | self.__PATH__=dev | |
36 | self.__FILE__ = os.open(dev, os.O_RDWR) |
|
36 | self.__FILE__ = os.open(dev, os.O_RDWR) |
General Comments 0
You need to be logged in to leave comments.
Login now