@@ -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 | 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 |
@@ -170,7 +170,7 byref(Mini), byref(Maxi)) | |||
|
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"), |
@@ -198,6 +198,17 class Discovery(): | |||
|
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 |
@@ -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("") |
@@ -19,7 +19,7 import serial | |||
|
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 | } |
@@ -19,11 +19,10 from scipy import fftpack | |||
|
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- |
|
|
26 |
i=np.argmax(powI)+index- |
|
|
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: |
@@ -32,31 +31,40 def __parseFFT(FFTi,FFTo,signalFreq,samp | |||
|
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 |
|
|
59 |
step=__step(device,freq |
|
|
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]) |
General Comments 0
You need to be logged in to leave comments.
Login now