diff --git a/.hgignore b/.hgignore --- a/.hgignore +++ b/.hgignore @@ -0,0 +1,2 @@ +syntax: glob +*.pyc diff --git a/lppinstru/discovery.py b/lppinstru/discovery.py --- a/lppinstru/discovery.py +++ b/lppinstru/discovery.py @@ -71,8 +71,8 @@ closed=False opened=True -class DiscoveryLimits(): - class limitRange(): +class DiscoveryLimits(object): + class limitRange(object): def __init__(self,Min,Max,name="Unknow",unit=""): self.Min = Min self.Max = Max @@ -170,7 +170,7 @@ byref(Mini), byref(Maxi)) return res -class Discovery(): +class Discovery(object): errors = {0: RuntimeError("No card opened"), 1: UserWarning("Parameter out of bound"), @@ -198,6 +198,17 @@ class Discovery(): def opened(self): return self.__opened + @property + def max_sampling_freq(self): + return self.__limits.ACQ_FREQ.Max + + @property + def min_sampling_freq(self): + return self.__limits.ACQ_FREQ.Min + + @property + def max_sampling_buffer(self): + return self.__limits.ACQ_BUF.Max ############################################################# # Power Supply diff --git a/lppinstru/dlp_temp.py b/lppinstru/dlp_temp.py --- a/lppinstru/dlp_temp.py +++ b/lppinstru/dlp_temp.py @@ -1,44 +1,127 @@ -#!/usr/bin/env python -#-*- coding: utf-8 -*- -"""Simple python library to drive DLP-TEMP module from www.dlpdesign.com -""" -import time -import sys -import os -import matplotlib.pyplot as plt -import numpy as np -import serial - -__author__ = "Alexis Jeandet" -__copyright__ = "Copyright 2015, Laboratory of Plasma Physics" -__credits__ = [] -__license__ = "GPLv2" -__version__ = "1.0.0" -__maintainer__ = "Alexis Jeandet" -__email__ = "alexis.jeandet@member.fsf.org" -__status__ = "Production" - -class dlp_temp(): - sensors = {0 : b'S', - 1 : b'T', - 2 : b'U', - } - def __init__(self,port): - self.i=0 - self.__port=serial.Serial(port,timeout=0.5) - - def ping(self): - self.__port.write(b"P") - return b'Q' == self.__port.read(1) - - def readSensor(self,index): - if index < 3: - self.__port.write(self.sensors.get(index)) - dat=self.__port.read(9) - test=( int(ord(dat[0])) + (int(ord(dat[1]))*256) ) - temp=float(test)*0.0625 - return temp #(temp-32.0)/1.8 - raise UserWarning("Parameter out of bound") - -if __name__ == '__main__': - print("") +#!/usr/bin/env python +#-*- coding: utf-8 -*- +"""Simple python library to drive DLP-TEMP module from www.dlpdesign.com +""" +import time +import sys +import os +import matplotlib.pyplot as plt +import numpy as np +import serial + +__author__ = "Alexis Jeandet" +__copyright__ = "Copyright 2015, Laboratory of Plasma Physics" +__credits__ = [] +__license__ = "GPLv2" +__version__ = "1.0.0" +__maintainer__ = "Alexis Jeandet" +__email__ = "alexis.jeandet@member.fsf.org" +__status__ = "Production" + +class dlp_temp(object): + sensors = {0 : b'S', + 1 : b'T', + 2 : b'U', + } + aninputs = {0 : b'A', + 1 : b'B', + 2 : b'C', + } + digitin= {0 : b'M', + 1 : b'N', + 2 : b'O', + } + digithigh= {0 : b'J', + 1 : b'K', + 2 : b'L', + } + digitlow= {0 : b'G', + 1 : b'H', + 2 : b'I', + } + def __init__(self,port): + self.i=0 + self.__port=serial.Serial(port,timeout=0.5) + + def ping(self): + self.__port.write(b"P") + return b'Q' == self.__port.read(1) + + def read_sensor(self,index): + if index < 3: + self.__port.write(self.sensors.get(index)) + dat=self.__port.read(9) + test=( int(ord(dat[0])) + (int(ord(dat[1]))*256) ) + temp=float(test)*0.0625 + return temp #(temp-32.0)/1.8 + raise UserWarning("Parameter out of bound") + + def read_analog_in(self,index): + if index < 3: + self.__port.write(self.aninputs.get(index)) + dat=self.__port.read(2) + test=( int(ord(dat[0])) + (int(ord(dat[1]))*256) ) + val=float(test)/512.0 + return val + raise UserWarning("Parameter out of bound") + + def digit_in(self,index): + if index < 3: + self.__port.write(self.digitin.get(index)) + dat=self.__port.read(1) + return dat + raise UserWarning("Parameter out of bound") + + def digit_out(self,index,val): + if index < 3: + if val: + self.__port.write(self.digithigh.get(index)) + else: + self.__port.write(self.digitlow.get(index)) + raise UserWarning("Parameter out of bound") + + @Property + def sensor1(self): + return read_sensor(0) + + @Property + def sensor2(self): + return read_sensor(1) + + @Property + def sensor3(self): + return read_sensor(2) + + @Property + def AN1(self): + return read_analog_in(0) + @Property + def AN2(self): + return read_analog_in(1) + @Property + def AN3(self): + return read_analog_in(2) + + @Property + def GP2(self): + return self.digit_in(0) + @GP2.setter + def GP2(self,value): + return self.digit_out(0,val) + + @Property + def GP0(self): + return self.digit_in(1) + @GP0.setter + def GP0(self,value): + return self.digit_out(1,val) + + @Property + def GP4(self): + return self.digit_in(2) + @GP4.setter + def GP4(self,value): + return self.digit_out(2,val) + +if __name__ == '__main__': + print("") diff --git a/lppinstru/gpd_xxx.py b/lppinstru/gpd_xxx.py --- a/lppinstru/gpd_xxx.py +++ b/lppinstru/gpd_xxx.py @@ -19,7 +19,7 @@ import serial __status__ = "Development" -class gpd_xxx(): +class gpd_xxx(object): conf = {"GPD-3303S" : (2,0.0,30.0), "GPD-3303" : (), } diff --git a/lppinstru/prologix_usb_gpib.py b/lppinstru/prologix_usb_gpib.py new file mode 100644 --- /dev/null +++ b/lppinstru/prologix_usb_gpib.py @@ -0,0 +1,73 @@ +#!/usr/bin/env python +#-*- coding: utf-8 -*- +"""Simple python library to communicate with Prologix USB GPIB module. +""" +import time +import sys +import os +import matplotlib.pyplot as plt +import numpy as np +import serial + +__author__ = "Alexis Jeandet" +__copyright__ = "Copyright 2015, Laboratory of Plasma Physics" +__credits__ = [] +__license__ = "GPLv2" +__version__ = "1.0.0" +__maintainer__ = "Alexis Jeandet" +__email__ = "alexis.jeandet@member.fsf.org" +__status__ = "Development" + +class UsbGpib(object): + modedic = {0:"DEVICE" , + 1:"CONTROLLER" ,} + revmodedic = {"DEVICE":"0" , + "CONTROLLER":"1" ,} + def __init__(self,port,address=0): + self._port=serial.Serial(port,timeout=0.1) + self._address=address + self._mode=1 + self.write("++ver") + self.version=self.read() + self.write("++auto 1") + + def set_as_device(self): + self.write("++mode 0") + def set_as_controller(self): + self.write("++mode 1") + + @property + def mode(self): + self.write("++mode") + self._mode= self.modedic[int(self.read())] + return self._mode + + @mode.setter + def mode(self,new_mode): + self._mode=self.revmodedic[new_mode] + self.write("++mode %d" % self._mode) + + @property + def address(self): + self._address=int(self.read("++addr")) + return self._address + + @address.setter + def address(self,value): + self._address=int(value) + self.write("++addr %d" % self._address) + + def write(self,command): + self._port.write(b"%s\n\r" % command) + self._port.flush() + + + def read(self,command="",GPIB=False): + if not command=="": + self.write(command) + if GPIB: + self.write("++read") + return self._port.readall() + + def idn(self): + return self.read("*IDN?") diff --git a/lppinstru/transfertFunction.py b/lppinstru/transfertFunction.py --- a/lppinstru/transfertFunction.py +++ b/lppinstru/transfertFunction.py @@ -19,11 +19,10 @@ from scipy import fftpack __status__ = "Development" - def __parseFFT(FFTi,FFTo,signalFreq,samplingFreq): index=signalFreq*len(FFTi)/samplingFreq - powI=np.abs(FFTi[index-4:index+4]) - i=np.argmax(powI)+index-4 + powI=np.abs(FFTi[int(index-1):int(index+1)]) + i=int(np.argmax(powI)+index-1) mod=np.abs(FFTo[i])/np.abs(FFTi[i]) arg=np.angle(FFTo[i])-np.angle(FFTi[i]) if arg<-np.pi: @@ -32,31 +31,40 @@ def __parseFFT(FFTi,FFTo,signalFreq,samp arg = (-np.pi*2)+arg return [signalFreq,mod,arg] +def __compute_params(device,freq): + Periods=5 + Fs=(freq*device.max_sampling_buffer)/Periods + if Fs < device.min_sampling_freq : + return [device.min_sampling_freq,device.max_sampling_buffer] + while Fs > (0.98*device.max_sampling_freq) : + Periods=Periods+1 + Fs=(freq*device.max_sampling_buffer)/Periods + return [Fs,device.max_sampling_buffer] + def __step(device,freq,offset=0.0,maxAmp=5.0,lastAmp=1.0): device.analog_out_gen(freq, shape='Sine', channel=0, amplitude=lastAmp, offset=offset) - samplesCount=8192 - if freq > 500000: - FS=freq*samplesCount/500.0 - elif freq > 100000: - FS=freq*samplesCount/50.0 - else: - FS=freq*samplesCount/10.0 - res=device.analog_in_read(ch1=True,ch2=True,frequency=FS,samplesCount=samplesCount,ch1range=5.0,ch2range=5.0) - FFTi=fftpack.fft(res[0][0]) - FFTo=fftpack.fft(res[0][1]) + params=__compute_params(device,freq) + res=device.analog_in_read(ch1=True,ch2=True,frequency=params[0],samplesCount=params[1],ch1range=5.0,ch2range=5.0) + meanI=np.mean(res[0][0]) + meanO=np.mean(res[0][1]) + FFTi=fftpack.fft((res[0][0]-meanI)*np.hamming(len(res[0][0]))) + FFTo=fftpack.fft((res[0][1]-meanO)*np.hamming(len(res[0][1]))) return __parseFFT(FFTi,FFTo,freq,res[1]) +def generateLogFreq(startFreq=1.0,stopFreq=100.0,nstep=100): + freq=np.zeros(nstep) + for i in range(int(nstep)) : + freq[i]=startFreq*np.power(10,((np.log10(stopFreq/startFreq))*i/(nstep-1))) + return freq def computeTF(device,startFreq=1.0,stopFreq=100.0,offset=0.0,maxAmp=5.0,nstep=100): - freq=np.zeros(nstep) + freqs=generateLogFreq(startFreq,stopFreq,nstep) f=[] mod=[] arg=[] - for i in range(int(nstep)) : - freq[i]=startFreq*np.power(10,((np.log10(stopFreq/startFreq))*i/(nstep-1))) lastAmp=0.1 - for i in range(len(freq)): - step=__step(device,freq[i],offset=offset,maxAmp=maxAmp,lastAmp=lastAmp) + for freq in freqs: + step=__step(device,freq,offset=offset,maxAmp=maxAmp,lastAmp=lastAmp) f.append(step[0]) mod.append(step[1]) arg.append(step[2]) diff --git a/lppinstru/usbtmc.py b/lppinstru/usbtmc.py --- a/lppinstru/usbtmc.py +++ b/lppinstru/usbtmc.py @@ -30,7 +30,7 @@ def find_instrument(ref,serial=""): return instrument return "" -class UsbTmc(): +class UsbTmc(object): def __init__(self,dev): self.__PATH__=dev self.__FILE__ = os.open(dev, os.O_RDWR)