diff --git a/Chimera.py b/Chimera.py index 0e662c1..2c7a2c1 100644 --- a/Chimera.py +++ b/Chimera.py @@ -1,204 +1,230 @@ import ChimeraSettings as C import ok import ChimeraControls import os import pickle from PyQt5 import QtGui import datetime import numpy as np import time import csv import matplotlib.pyplot as plt +import functions from matplotlib.ticker import EngFormatter Amp = EngFormatter(unit='A', places=2) Time = EngFormatter(unit='s', places=2) Volt = EngFormatter(unit='V', places=2) Cond = EngFormatter(unit='S', places=2) # Main Chimera Launcher class Launcher: def __init__(self, loadedInstance=None): if loadedInstance is None: self.ChimeraSettings = C.ChimeraSettings() else: self.ChimeraSettings = loadedInstance + # Initialize Chimera self.xem = ok.FrontPanel() - - # Contains all variables ChimeraControls.InitializeChimera(self.ChimeraSettings,self.xem) + # Set savingfolder self.SetSavingFolder(os.getcwd()) + # Variables + self.lowpass = 2e3 + self.displaySamplerate = self.lowpass*2 + + self.IVUseAlternatingV = True + self.LowerIV = 0.0 + self.HigherIV = 0.0 + self.StepIV = 0.0 + self.timeIV = 2 + + # if os.stat("store.pckl").st_size: # ChimeraSettings.setStoredValues() # Data variables # self.blockvalues = np.empty((1048576,), dtype=np.uint16) # self.readvalues = ChimeraControls.ConvertBlockvalues(self.ChimeraSettings, blockvalues) + #self.displaybuffer + #self.blockvalues # self.newbiasvalue = 0 + def Initialize(self): ChimeraControls.InitializeChimera(self.ChimeraSettings, self.xem) def SetSavingFolder(self, savingFolder, experimentName = 'Untitled'): self.DataFolder = savingFolder self.todaysfolder = str(datetime.date.today()) self.experimentName = experimentName if not os.path.exists(self.DataFolder): os.makedirs(self.DataFolder) if not os.path.exists(os.path.join(self.DataFolder, self.todaysfolder)): os.makedirs(os.path.join(self.DataFolder, self.todaysfolder)) print('Files are saved in ' + os.path.join(os.path.join(self.DataFolder, self.todaysfolder), self.experimentName)) def SetExperimentName(self, experimentName): self.SetSavingFolder(self.DataFolder, experimentName=experimentName) def SetVoltage(self, sb, write=True): self.newbiasvalue = sb # self.ChimeraSettings.RestartBuffer = True if write: self.SaveVoltage() ChimeraControls.CHIMERA_updateDACvalues1(self.ChimeraSettings, self.xem, self.newbiasvalue) def RecordTraceRaw(self): blockvalues = ChimeraControls.CHIMERA_process_triggers(self.ChimeraSettings,self.xem) #self.blockvalues = blockvalues readvalues = ChimeraControls.ConvertBlockvalues(self.ChimeraSettings, blockvalues) #self.readvalues = readvalues return readvalues def RecordTrace(self): blockvalues = ChimeraControls.CHIMERA_process_triggers(self.ChimeraSettings,self.xem) #self.blockvalues = blockvalues readvalues = ChimeraControls.ConvertBlockvalues(self.ChimeraSettings, blockvalues) #self.readvalues = readvalues - displaybuffer = ChimeraControls.lowpass(self.ChimeraSettings, readvalues, cutoff=None) - #self.displaybuffer = displaybuffer + Samplerate = self.ChimeraSettings.ADCSAMPLERATE + displaybuffer, self.displaySamplerate = functions.lowpass(readvalues, Samplerate, self.lowpass) + + #displaybuffer = ChimeraControls.lowpass(self.ChimeraSettings, readvalues, cutoff=self.lowpass) return displaybuffer #def SaveSettings(self, fileName): # if fileName is not None and not os.path.exists(fileName): # filePath = os.path.split(fileName) # if not os.path.isdir(filePath): # os.mkdir(filePath) # else: # fileName = QtGui.QFileDialog.getOpenFileName() # fileName = fileName[0] # print(fileName) # # f = open(fileName, 'rb') # ChimeraSettings = self.ChimeraSettings # pickle.dump(ChimeraSettings, f) # f.close() # print('Saved as ' + fileName) def LoadInstance(self, fileName): if fileName is None or os.path.exists(fileName): fileName = QtGui.QFileDialog.getOpenFileName() fileName = fileName[0] print(fileName) f = open(fileName, 'rb') ChimeraSettings = pickle.load(f) f.close() self.ChimeraSettings = ChimeraSettings print('Loaded from ' + fileName + '. Re-initializing...') ChimeraControls.InitializeChimera(self.ChimeraSettings, self.xem) def updateBW(self): out = ChimeraControls.CHIMERA_bandwidthtimer(self.ChimeraSettings, self.xem) text1 = "Time\n{0}\nUSB Read Rate\n{1:} kHz\nUSB Write Rate\n{2}".format(out['text_time'], out['USB_readrate'], out['USB_writerate']) print(text1) text2 = "Buffer\n{0} kB\nBuffer Size\n{1} %\nSeconds buffered\n{2:.3f} sec".format(out['buffer'], out['bufferPC'], out['bufferseconds']) print(text2) # def update(self): # def PlotData(self): def ResetBuffer(self): print("Buffer is resetting...") ans1 = self.xem.SetWireInValue(self.ChimeraSettings.EP_WIREIN_TEST1, self.ChimeraSettings.EPBIT_GLOBALRESET, self.ChimeraSettings.EPBIT_GLOBALRESET) self.xem.UpdateWireIns() time.sleep(0.1) ans2 = self.xem.SetWireInValue(self.ChimeraSettings.EP_WIREIN_TEST1, 0, self.ChimeraSettings.EPBIT_GLOBALRESET) self.xem.UpdateWireIns() #self.RestartBuffer = 1 def ZeroVolt(self): Vdelta = 0.02 print('Measuring at {} ...'.format(Volt.format_data(Vdelta)), end='') self.SetVoltage(Vdelta, write=False) self.ResetBuffer() time.sleep(1) measI1 = np.mean(self.RecordTrace()) print('{}'.format(Amp.format_data(measI1))) print('Measuring at {} ...'.format(Volt.format_data(0)), end='') self.SetVoltage(0, write=False) self.ResetBuffer() time.sleep(1) measI2 = np.mean(self.RecordTrace()) print('{}'.format(Amp.format_data(measI2))) deltaI = measI1-measI2 if deltaI == 0: print('Error, cannot zero voltage: deltaI = 0') else: measR = Vdelta / deltaI self.ResetBuffer() self.ChimeraSettings.voltageOffset += -measI2 * measR print('New voltage offset: {}'.format(Volt.format_data(self.ChimeraSettings.voltageOffset))) ChimeraControls.CHIMERA_updateDACvalues1(self.ChimeraSettings, self.xem) self.SetVoltage(self.ChimeraSettings.voltageOffset) def SaveVoltage(self): savingFolder = os.path.join(self.DataFolder, self.todaysfolder) savingName = self.experimentName + 'Vdata.csv' fullpath = os.path.join(savingFolder, savingName) data = [datetime.datetime.now(), self.newbiasvalue] with open(fullpath, 'w') as csvfile: writeline = csv.writer(csvfile, delimiter=',') writeline.writerows(data) class ChimeraPlot: - def __init__(self): + def __init__(self, Chimera): self.fig, self.ax = plt.subplots(1, 1) - self.ax.set_xlabel('X') - self.ax.set_ylabel('Y') + self.ax.set_xlabel('Time [s]') + self.ax.set_ylabel('Current [nA]') + + self.samplerate = Chimera.displaySamplerate def Update(self, trace): - x = np.linspace(0, 1, len(trace)) + + x = np.arange(len(g.trace)) / self.samplerate + + currentIDC = np.mean(g.displaybuffer) + currentRMS = np.std(g.displaybuffer) + if self.ax.lines: for line in self.ax.lines: line.set_xdata(x) line.set_ydata(trace) else: self.ax.plot(x, trace) + + self.ax.set_ylim([currentIDC - 10 * currentRMS, currentIDC + 10 * currentRMS]) self.fig.canvas.draw() diff --git a/ChimeraControls.py b/ChimeraControls.py index b713c14..82c06c6 100644 --- a/ChimeraControls.py +++ b/ChimeraControls.py @@ -1,216 +1,216 @@ #import ChimeraSettings import os import sys import numpy as np import scipy from scipy import signal as si import math import time import datetime def upsample(s, n, phase=0): """Increase sampling rate by integer factor n with included offset phase. """ return np.roll(np.kron(s, np.r_[1, np.zeros(n-1)]), phase) def InitializeChimera(ChimeraSettings, xem): ndevices = xem.GetDeviceCount() if ndevices == 0: print('No Device Attached!!') return -1 serials = xem.GetDeviceListSerial(0) models = xem.GetDeviceListModel(0) print('OK Devices detected (Model: {}) . Serial number of device 1 is {Serial} '.format(ndevices, models, Serial=serials)) bitfilename = 'bitfile_fpga_spartan6_usb3.bit' openanswer = xem.OpenBySerial(serials) print('Device opened with code {}'.format(openanswer)) confanswer = xem.ConfigureFPGA(bitfilename) print('Device configured with code {}'.format(confanswer)) ans1 = xem.SetWireInValue(ChimeraSettings.EP_WIREIN_TEST1, ChimeraSettings.EPBIT_GLOBALRESET, ChimeraSettings.EPBIT_GLOBALRESET) xem.UpdateWireIns() time.sleep(0.1) ans2 = xem.SetWireInValue(ChimeraSettings.EP_WIREIN_TEST1, ChimeraSettings.EPBIT_ENABLEADCFIFO, ChimeraSettings.EPBIT_ENABLEADCFIFO) xem.UpdateWireIns() time.sleep(0.1) ans3 = xem.SetWireInValue(ChimeraSettings.EP_WIREIN_TEST1, 0, ChimeraSettings.EPBIT_GLOBALRESET) xem.UpdateWireIns() time.sleep(0.1) ans4 = xem.SetWireInValue(ChimeraSettings.EP_WIREIN_TEST1, ChimeraSettings.EPBIT_HEADSTAGE_PWR_LED, ChimeraSettings.EPBIT_HEADSTAGE_PWR_LED) xem.UpdateWireIns() time.sleep(0.1) CHIMERA_updateDACvalues1(ChimeraSettings,xem,0) CHIMERA_updateDPOTvalues1(ChimeraSettings, xem) # Set Input SetADCInput(ChimeraSettings, xem, 'Filtered') outtext = CHIMERA_bandwidthtimer(ChimeraSettings, xem) def CHIMERA_process_triggers(ChimeraSettings,xem): xem.UpdateTriggerOuts() ba = bytearray(ChimeraSettings.ADC_pkt_len) out = xem.ReadFromBlockPipeOut(ChimeraSettings.EP_PIPEOUT_ADC, ChimeraSettings.ADC_xfer_blocksize, ba) #print(out) #int=np.uint8(ba) #bytesread = len(readbytes) #typecasted = int.view(np.uint32) blockvalues = np.uint16((np.uint8(ba)).view(np.uint32)) return blockvalues #globals.read_monitor += 2*len(globals.blockvalues) ?? def ConvertBlockvalues(ChimeraSettings,readvalues): #readvalues=g.blockvalues mygain = ChimeraSettings.SETUP_TIAgain * ChimeraSettings.SETUP_preADCgain bitmask = (2**16 - 1) - (2**(16-ChimeraSettings.ADCBITS) - 1) readvalues = -ChimeraSettings.ADCVREF + (2*ChimeraSettings.ADCVREF) * (readvalues & bitmask) / 2**16 readvalues = 10**9*(readvalues/mygain + ChimeraSettings.SETUP_pAoffset) return readvalues def lowpass(ChimeraSettings, readvalues, cutoff = None): #currentRMSRaw = np.std(readvalues) if cutoff is None: displaybuffer = si.resample(readvalues, int(1/ChimeraSettings.displaysubsample*len(readvalues))) else: downsampled = si.resample(readvalues, int(1/ChimeraSettings.displaysubsample*len(readvalues))) effsamplerate=(ChimeraSettings.ADCSAMPLERATE/ChimeraSettings.displaysubsample) Wn = round(2*cutoff/effsamplerate, 4) b, a = si.bessel(4, Wn, btype='low', analog=False) displaybuffer = si.filtfilt(b, a, downsampled) - displaybuffer =g.displaybuffer[100:len(displaybuffer)-100] + displaybuffer = displaybuffer[100:len(displaybuffer)-100] return displaybuffer def CHIMERA_updateDACvalues1(ChimeraSettings,xem, newbiasvalue): Cfastvalue = ChimeraSettings.CFAST_CAP0 #Cfastvalue = globals.CFAST_CAP0+globals.CFAST_CAP1 #for extended range newCfastDACvoltage = - newbiasvalue * ChimeraSettings.myCfast / (ChimeraSettings.CFAST_gain*Cfastvalue) biasDACcode = np.uint16((-newbiasvalue - ChimeraSettings.voltageOffset + 0.5 * ChimeraSettings.DACFULLSCALE)/ChimeraSettings.DACFULLSCALE*(math.pow(2, ChimeraSettings.DACBITS))) fastcDACcode = np.uint16((-newCfastDACvoltage + 0.5*ChimeraSettings.DACFULLSCALE)/ChimeraSettings.DACFULLSCALE * (math.pow(2, ChimeraSettings.DACBITS))) mydacvector = np.uint32(VECTOR_biasDAC_AD5541A(ChimeraSettings,biasDACcode,fastcDACcode)) CHIMERA_sendscanvector1(ChimeraSettings, xem, np.transpose(mydacvector)) def CHIMERA_sendscanvector1(ChimeraSettings,xem, scanvectorfile): bitinversions = 0 pack32 = np.uint32(scanvectorfile) packbixor = pack32 | bitinversions packet1 = packbixor.view(np.uint8) packet = bytearray(packet1) modu = np.mod(len(packet), 16) if modu: packet.reverse() for x in range(0, modu): packet.append(0) packet.reverse() bytes_sent = xem.WriteToPipeIn(ChimeraSettings.EP_PIPEIN_SCANCHAINS, packet) def CHIMERA_updateDPOTvalues1(ChimeraSettings, xem): myDPOTvalue = ChimeraSettings.freqComp DPOTbits = 8 DPOTcode = np.uint8(np.round(myDPOTvalue/100*(math.pow(2,DPOTbits)))) mydacvector = np.concatenate([VECTOR_DPOT_AD5262(ChimeraSettings, DPOTcode, 0), VECTOR_DPOT_AD5262(ChimeraSettings, DPOTcode, 1)]) CHIMERA_sendscanvector1(ChimeraSettings, xem, mydacvector) def VECTOR_DPOT_AD5262(ChimeraSettings, DPOTvalue, DPOTaddress): DPOTdata = np.zeros(ChimeraSettings.DPOT_SCANCHAIN_LENGTH, dtype=np.int) DPOTdata[ChimeraSettings.DPOT_A-1] = DPOTaddress DPOTbits = 8 getBin = lambda x, n: x >= 0 and str(bin(x))[2:].zfill(n) or "-" + str(bin(x))[3:].zfill(n) binaryarray = getBin(DPOTvalue,DPOTbits) binaryarray = np.array(list(binaryarray),dtype=int) DPOTdata[ChimeraSettings.DPOT_LSB-1:ChimeraSettings.DPOT_MSB] = np.flipud(binaryarray) returnvector = ChimeraSettings.EPBIT_DPOT_SDI * DPOTdata returnvector1 = np.array(upsample(returnvector,2,0), dtype=np.int) returnvector2 = np.array(upsample(returnvector,2,1), dtype=np.int) returnvector = returnvector1 + returnvector2 vectorlength = len(returnvector) v = np.arange(2, vectorlength + 2, dtype=np.int) myclk = 0.5 + 0.5 * scipy.signal.square(1/1*3.1416*v) returnvector = returnvector + np.array(ChimeraSettings.EPBIT_DPOT_CLK * myclk,dtype=np.int) returnvector = np.flipud(returnvector) returnvector = np.concatenate((np.array([ChimeraSettings.EPBIT_DPOT_NCS,0],dtype=int), returnvector, np.array([0, ChimeraSettings.EPBIT_DPOT_NCS],dtype=int))) returnvector = returnvector + np.array(ChimeraSettings.EP_ACTIVELOWBITS-ChimeraSettings.EPBIT_DPOT_NCS,dtype=int) return returnvector def VECTOR_biasDAC_AD5541A(ChimeraSettings,biasdacvalue, fastcdacvalue): biasDACdata = np.zeros(ChimeraSettings.DAC_SCANCHAIN_LENGTH, dtype=np.int) fastcDACdata = np.zeros(ChimeraSettings.DAC_SCANCHAIN_LENGTH, dtype=np.int) DACbits = 16 biasDACbinary = np.zeros(DACbits, dtype=np.int) binarystring = "{0:b}".format(biasdacvalue) binaryarray = np.array(list(binarystring), dtype=int) biasDACbinary[DACbits-len(binaryarray):DACbits] = binaryarray fastcDACbinary = np.zeros(DACbits, dtype=np.int) binarystring = "{0:b}".format(fastcdacvalue) binaryarray = np.array(list(binarystring), dtype=int) fastcDACbinary[DACbits-len(binaryarray):DACbits] = binaryarray biasDACdata = np.flipud(biasDACbinary) fastcDACdata = np.flipud(fastcDACbinary) returnvector = ChimeraSettings.EPBIT_DACSDI * biasDACdata + ChimeraSettings.EPBIT_DACSDI_FASTC * fastcDACdata upreturn = upsample(returnvector,2,0) + upsample(returnvector,2,1) vectorlength = len(upreturn) v = np.arange(2, vectorlength + 2, dtype=np.int) myclk = 0.5 + 0.5*scipy.signal.square(1/1*3.1416*v) returnvector = upreturn + ChimeraSettings.EPBIT_DACCLK*myclk returnvector = np.flipud(returnvector) returnvector = np.concatenate([[ChimeraSettings.EPBIT_DACNCS + ChimeraSettings.EPBIT_DAC_NLOAD, ChimeraSettings.EPBIT_DACNCS + ChimeraSettings.EPBIT_DAC_NLOAD, ChimeraSettings.EPBIT_DAC_NLOAD], returnvector + ChimeraSettings.EPBIT_DAC_NLOAD, [ChimeraSettings.EPBIT_DACNCS + ChimeraSettings.EPBIT_DAC_NLOAD, ChimeraSettings.EPBIT_DACNCS + ChimeraSettings.EPBIT_DAQTRIGGER, ChimeraSettings.EPBIT_DACNCS + ChimeraSettings.EPBIT_DAC_NLOAD]]) returnvector = returnvector + (ChimeraSettings.EP_ACTIVELOWBITS - ChimeraSettings.EPBIT_DACNCS - ChimeraSettings.EPBIT_DAC_NLOAD) lastelement = returnvector[len(returnvector)-1] returnvector = np.concatenate([returnvector, lastelement*np.ones(32)]) return returnvector def SetADCInput(ChimeraSettings, xem, mux): wiremask = ChimeraSettings.EPBIT_ADC1MUX0 + ChimeraSettings.EPBIT_ADC1MUX1 wirevalue=0 if mux == 'VIN1': wirevalue = wirevalue + ChimeraSettings.EPBIT_ADC1MUX1 if mux == 'Filtered': wirevalue = wirevalue + ChimeraSettings.EPBIT_ADC1MUX0 if mux == 'AUXJ14': wirevalue = 3 if mux == 'Unfiltered': wirevalue = 0 out = xem.SetWireInValue(ChimeraSettings.EP_WIREIN_ADCMUX, wirevalue, wiremask) xem.UpdateWireIns() # Bandwith Timer def CHIMERA_bandwidthtimer(ChimeraSettings, xem): np.set_printoptions(precision=3) #globals.init() mytime=datetime.datetime.today()-ChimeraSettings.timezero mytimestring=str(mytime) text_time=mytimestring text_readrate=ChimeraSettings.read_monitor/2000 text_writerate=ChimeraSettings.write_monitor/2000 xem.UpdateWireOuts() fifolevel = 4*(xem.GetWireOutValue(ChimeraSettings.EP_WIREOUT_ADCFIFOCOUNT) & int('0111111111111111', 2)) #globals.write_monitor=0 #globals.read_monitor=0 textOutputs = {'text_time': text_time, 'USB_readrate': text_readrate,'USB_writerate':text_writerate,'buffer':fifolevel, 'bufferPC': math.floor(100*fifolevel/ChimeraSettings.HWBUFFERSIZE_KB), 'bufferseconds': fifolevel*1024/(100e6 / 24 * 2)} return textOutputs \ No newline at end of file diff --git a/ChimeraSettings.py b/ChimeraSettings.py index 16f100a..acfa2df 100644 --- a/ChimeraSettings.py +++ b/ChimeraSettings.py @@ -1,163 +1,156 @@ import datetime import numpy as np import pickle class ChimeraSettings: def __init__(self): # Make sure this corresponds to your chimera calibration self.freqComp = 19 self.SETUP_pAoffset = 1365e-12 self.SETUP_TIAgain = 100e6 self.SETUP_preADCgain = 1.235 self.k = 1.3806503e-23 self.T = 298 self.IVOn = 0 self.currentIDC = 0 self.currentRMS = 0 self.newbiasvalue = 0 self.myCfast = 11E-12 self.voltageOffset = -274E-3 - self.IVUseAlternatingV = True - self.LowerIV = 0.0 - self.HigherIV = 0.0 - self.StepIV = 0.0 - self.timeIV = 2 - # self.AllVoltages = 0 # self.IVCurrentV = 0.0 self.Threshold = 8 self.EventLimit = 0 self.currentRMSRaw = 0 - self.fisopen = 0 # self.file = 0 # self.writtenBlocks = 0 # self.blockvalues = np.empty((1048576,), dtype=np.uint16) self.StockTime = 4 self.StockData = np.empty((0,), dtype=np.uint16) # self.RestartBuffer = 0 # Zaps self.ZapVoltage = -0.3 self.ZapTime = 0.5 self.ZapFrequency = 2 self.VoltageBeforeZap = 0.0 self.ZapOnce = 0 # VoltageBeforeZap = 0.0 self.ZappingInputChoice = 0 self.SAVECONFIGFILE = "startupconfig.mat" self.EVENTLOGFILE = "EVENT_LOG.txt" self.LOGFILE_DIR = "logfiles" self.FPGAMODEL = "spartan6_usb3" # CLK1FREQDEFAULT = 100e6; # CLK2FREQDEFAULT = 4e6; self.ADCSAMPLERATE = 100e6 / 24 self.HWBUFFERSIZE_KB = 128 * 1024 self.ADCMUXDEFAULT = 2 self.RAWDATAFORMAT = 'uint32' self.MAXLOGBYTES = 20e6 self.CFAST_gain = 2 self.CFAST_CAP0 = 1e-12 self.CFAST_CAP1 = 10e-12 self.ADC_xfer_len = 4 * 1024 * 1024 ##Todo delete? self.ADC_pkt_len = self.ADC_xfer_len self.ADC_xfer_blocksize = 512 self.ADCcaptureenable = 1 self.ADCnumsignals = 1 self.ADCBITS = 14 # this may get overwritten by startupconfig.mat self.ADCVREF = 2.5 # this may get overwritten by startupconfig.mat self.ADClogenable = 0 self.ADClogsize = 0 self.ADClogreset = 0 self.logfid = -1 self.DACBITS = 16 self.DACFULLSCALE = 4.5 self.DACcurrent = 0 self.DACprevious = 0 self.ADC_xfer_time = self.ADC_xfer_len / self.ADCSAMPLERATE self.EP_TRIGGERIN_TEST1 = int('40', 16) self.EP_TRIGGEROUT_TEST1 = int('60', 16) self.EP_WIREIN_TEST1 = int('00', 16) self.EP_WIREIN_ADCMUX = int('01', 16) self.EP_WIREOUT_TEST1 = int('20', 16) self.EP_WIREOUT_ADCFIFOCOUNT = int('21', 16) self.EP_PIPEIN_SCANCHAINS = int('80', 16) self.EP_PIPEOUT_ADC = int('A0', 16) BITMASK_ALL = int("ffff", 16) BITMASK_0 = int("0001", 16) BITMASK_1 = int("0002", 16) BITMASK_2 = int("0004", 16) BITMASK_3 = int("0008", 16) BITMASK_4 = int("0010", 16) BITMASK_5 = int("0020", 16) BITMASK_6 = int("0040", 16) BITMASK_7 = int("0080", 16) BITMASK_8 = int("0100", 16) BITMASK_9 = int("0200", 16) BITMASK_10 = int("0400", 16) BITMASK_11 = int("0800", 16) BITMASK_12 = int("1000", 16) BITMASK_13 = int("2000", 16) BITMASK_14 = int("4000", 16) BITMASK_15 = int("8000", 16) self.EPBIT_ENABLEADCFIFO = BITMASK_4 self.EPBIT_GLOBALRESET = BITMASK_15 self.EPBIT_DACSDI = BITMASK_0 self.EPBIT_DACCLK = BITMASK_1 self.EPBIT_DACNCS = BITMASK_2 self.EPBIT_DACSDI_FASTC = BITMASK_8 self.EPBIT_DAC_NLOAD = BITMASK_10 self.EPBIT_DPOT_CLK = BITMASK_4 self.EPBIT_DPOT_SDI = BITMASK_5 self.EPBIT_DPOT_NCS = BITMASK_6 self.EPBIT_FASTC_CAPMUX = BITMASK_9 self.EPBIT_DAQTRIGGER = BITMASK_15 self.EPBIT_ADCDATAREADY = BITMASK_0 self.EPBIT_ADC1MUX0 = BITMASK_0 self.EPBIT_ADC1MUX1 = BITMASK_1 self.EPBIT_HEADSTAGE_PWR_EN = BITMASK_0 self.EPBIT_HEADSTAGE_PWR_LED = BITMASK_1 self.EP_ACTIVELOWBITS = self.EPBIT_DACNCS + self.EPBIT_DAC_NLOAD + self.EPBIT_DPOT_NCS self.DAC_SCANCHAIN_LENGTH = 16 self.DAC_MSB = 16 self.DAC_LSB = 1 self.DPOT_SCANCHAIN_LENGTH = 9 self.DPOT_A = 9 self.DPOT_MSB = 8 self.DPOT_LSB = 1 self.read_monitor = 0 self.write_monitor = 0 self.timezero = datetime.datetime.today() - self.displaybuffertime = np.floor(self.ADC_xfer_time * 10) / 50 - self.displaycount = 1 - self.displayupdaterate = 2 + #self.displaybuffertime = np.floor(self.ADC_xfer_time * 10) / 50 + #self.displaycount = 1 + #self.displayupdaterate = 2 self.displaysubsample = 16 # self.displaybuffersize = int(np.ceil(self.ADCnumsignals * self.ADCSAMPLERATE * self.displaybuffertime / self.displaysubsample)) # self.displaybuffer = np.zeros(self.displaybuffersize, dtype=np.float) - self.flag = 0 - self.ChimeraIsOn = 1 + #self.flag = 0 + #self.ChimeraIsOn = 1 def setStoredValues(self): f = open('store.pckl', 'rb') variables = pickle.load(f) print('Loaded Variables: {}'.format(variables)) self.voltageOffset = variables['Voffset'] self.SETUP_pAoffset = variables['pAOffset'] self.LowerIV = variables['LowerIV'] self.HigherIV = variables['HigherIV'] self.StepIV = variables['StepIV'] self.experimentName = variables['experimentName'] # self.timeIV = variables['timeIV'] f.close diff --git a/functions.py b/functions.py new file mode 100644 index 0000000..178beb4 --- /dev/null +++ b/functions.py @@ -0,0 +1,40 @@ +import scipy +from scipy import signal +import numpy as np + +def LowPass(data, samplerate, lowPass): + """ + Function used to filter data with a digital Bessel filter of the 4th order. + + Specially useful for high bandwidth recordings. + + Parameters + ---------- + data : + Data to be filtered. + samplerate : float + Sampling frequency of the data aquisition. + lowPass : float + Cutoff frequency of the filter. + + Returns + ------- + output: a list of the currents filtered + newsamplerate : float of new sampling frequency corresponding to 2*Cutoff frequency (Nyquist-Shannon sampling theorem). + + """ + + Wn = round(2 * lowPass / samplerate, 4) # [0,1] nyquist frequency + b, a = signal.bessel(4, Wn, btype='low', analog=False) # 4-th order digital filter + + z, p, k = signal.tf2zpk(b, a) + eps = 1e-9 + r = np.max(np.abs(p)) + approx_impulse_len = int(np.ceil(np.log(eps) / np.log(r))) + Filt_sig = (signal.filtfilt(b, a, data, method='gust', irlen=approx_impulse_len)) + + ds_factor = np.ceil(samplerate / (2 * lowPass)) + output = {} + output = scipy.signal.resample(Filt_sig, int(len(data) / ds_factor)) + newsamplerate = samplerate / ds_factor + return output, newsamplerate \ No newline at end of file