def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
degChannels = []
self.unitFactors = [0. for i in range(8)]
for i in range(1, 9):
#Check if channel can be used (left and right limit tripped indicates failure or missing device)
if int(self.askAndLog(str(i) + "MS").strip()[3].encode("hex"),
16) & 0x18 == 0x18:
continue
#Check the units
unit = self.askAndLog(str(i) + "SN?").strip()[3:]
self.unitFactors[i] = 1.
if unit == "Dg.":
degChannels.append("ch" + str(i) + "deg")
elif unit == "mm":
degChannels.append("ch" + str(i) + "mm")
self.unitFactors[i] = .001
else:
degChannels.append("ch" + str(i) + "unknown")
#Set maximum velocity
vmax = self.askAndLog(str(i) + "VU?")[3:]
self.writeAndLog(str(i) + "VA" + vmax)
self.instrCfg.setInstalledOptions(degChannels)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# do additional initialization code here...
#Hacky way to make sure the input buffer is flushed out
try:
self.reportProgress(1 / 8)
_ = self.read(1024)
except:
pass
#Flush everything (hopefully)
self.writeAndLog('*CLS')
self.writeAndLog('FLOQ')
#Step through each channel and query ID
#Build up a dict of IDN/Channel pairs
self.ports_dict = {}
for ix in range(8):
channel = ix + 1
idn = self.sim900_module_ask(channel,
'*IDN?',
timeout=0.5,
bCheckError=False)
if idn not in ['None', 'Timed Out']:
module_code = idn.split(',')[1]
self.ports_dict[module_code] = channel
else:
module_code = idn
self.setValue('Slot %d' % channel, module_code)
self.reportProgress(channel / 8)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# init meas param dict
self.dMeasParam = {}
self.cData=None
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
# perform special getValue for reading complex value
name = str(quant.name)
if name == 'Value':
# get complex value in one instrument reading
sCmd = 'SNAP?1,2'
sAns = self.askAndLog(sCmd).strip()
lData = sAns.split(',')
# return complex values
return complex(float(lData[0].strip()), float(lData[1].strip()))
elif name == 'R':
#convert resistance to Kelvin
R_volt = VISA_Driver.performGetValue(self, quant, options=options)
Amp = 0.01 # 0.01 V
R_std = 10e6 # standard resistance in Ohm
R1 = R_volt / (Amp / R_std) # R: resistance of thermometer
if R1 > 3590:
Temp = 377 * ((1 / (R1 - 1500)) + 8.22e-6)**0.86296
else:
Temp = 4031 * ((1 / (R1 - 997.7)) + 4.54e-5)**1.15512
return Temp
else:
# run the generic visa driver case
return VISA_Driver.performGetValue(self, quant, options=options)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
degChannels = []
self.unitFactors = [0. for i in range(8)]
for i in range(1,9):
#Check if channel can be used (left and right limit tripped indicates failure or missing device)
if int(self.askAndLog(str(i)+"MS").strip()[3].encode("hex"), 16) & 0x18 == 0x18:
continue
#Check the units
unit = self.askAndLog(str(i)+"SN?").strip()[3:]
self.unitFactors[i] = 1.
if unit == "Dg.":
degChannels.append("ch"+str(i)+"deg")
elif unit == "mm":
degChannels.append("ch"+str(i)+"mm")
self.unitFactors[i] = .001;
else:
degChannels.append("ch"+str(i)+"unknown")
#Set maximum velocity
vmax = self.askAndLog(str(i)+"VU?")[3:]
self.writeAndLog(str(i)+"VA"+vmax)
self.instrCfg.setInstalledOptions(degChannels)
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
if quant.name in ('Wait for new trace', ):
# do nothing
pass
elif quant.name in ('Marker 1 - Function', ):
m_idx = int(quant.name[7])
if self.getValue(quant.name) == 'Band Power':
self.writeAndLog('CALC:MARK%d:FUNC:BPOW:STAT ON' % m_idx)
elif self.getValue(quant.name) == 'Noise Density':
self.writeAndLog('CALC:MARK%d:FUNC:NOIS ON' % m_idx)
else:
pass
elif quant.name in ('RBW', 'VBW', 'Detector', 'Sweep Time',
'Input Attenuation'):
# manual performSetValue operation on certain quantities only if automatic setting is unchecked in the driver
if not self.getValue(quant.name + ' - Auto'):
# run standard VISA case
value = VISA_Driver.performSetValue(self, quant, value,
sweepRate, options)
else:
# if automatic setting is checked, read the value from the instrument and save to local driver
value = self.setValue(quant.name,
self.readValueFromOther(quant.name))
else:
# run standard VISA case
value = VISA_Driver.performSetValue(self, quant, value, sweepRate,
options)
return value
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
#Reads out the Arduino upon start
reply = self.read()
self.log('Response at startup: ' + reply)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# open visa communication
VISA_Driver.performOpen(self, options)
# set additional flags
self.com.set_visa_attribute(VI_ATTR_WR_BUF_OPER_MODE,
VI_FLUSH_ON_ACCESS)
self.com.set_visa_attribute(VI_ATTR_RD_BUF_OPER_MODE,
VI_FLUSH_ON_ACCESS)
read_buff_size_bytes = 4096
write_buff_size_bytes = 4096
self.com.visalib.set_buffer(self.com.session, VI_READ_BUF,
read_buff_size_bytes)
self.com.__dict__['read_buff_size'] = read_buff_size_bytes
self.com.visalib.set_buffer(self.com.session, VI_WRITE_BUF,
write_buff_size_bytes)
self.com.__dict__['write_buff_size'] = write_buff_size_bytes
# timeout
self.timeout_ms = int(1000 * self.dComCfg['Timeout'])
self.nCh = 2
self.lWaveUpdated = [False] * self.nCh
# clear all waveforms
self.writeAndLog(':TRAC:DEL:ALL')
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function
should return the actual value set by the instrument."""
# check quantity name
if quant.name == 'FrequencyA':
self.writeAndLog('C0')
self.writeAndLog('f%f' % (1.e-6 * value))
elif quant.name == 'PowerA':
self.writeAndLog('C0')
self.writeAndLog('W%f' % value)
elif quant.name == 'OutputA':
self.writeAndLog('C0')
self.writeAndLog('r%d' % value)
elif quant.name == 'FrequencyB':
self.writeAndLog('C1')
self.writeAndLog('f%f' % (1.e-6 * value))
elif quant.name == 'PowerB':
self.writeAndLog('C1')
self.writeAndLog('W%f' % value)
elif quant.name == 'OutputB':
self.writeAndLog('C1')
self.writeAndLog('r%d' % value)
else:
# otherwise, call standard VISA case
VISA_Driver.performSetValue(self, quant, value, sweepRate, options)
return value
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# add compatibility with pre-python 3 version of Labber
if not hasattr(self, 'write_raw'):
self.write_raw = self.write
# add compatibility with pre-1.5.4 version of Labber
if not hasattr(self, 'getTrigChannel'):
self.getTrigChannel = self._getTrigChannel
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options)
# check for strange bug by reading the status bit
try:
status = self.askAndLog('*STB?', bCheckError=False)
status = int(status)
except:
# if conversion to int failed, re-read instrument buffer to clear
sBuffer = self.read()
self.log('Extra data read from Tek: %s, %s' %
(str(status), sBuffer))
# get model name and number of channels
sModel = self.getModel()
self.nCh = 4 if sModel in ('5004', '5014') else 2
# turn off run mode
self.writeAndLog(':AWGC:STOP;')
# init vectors with old values
self.bWaveUpdated = False
self.nOldSeq = -1
self.lOldU16 = [[np.array([], dtype=np.uint16) \
for n1 in range(self.nCh)] for n2 in range(1)]
# clear old waveforms
self.lInUse = [False] * self.nCh
for n in range(self.nCh):
self.createWaveformOnTek(n + 1, 0, bOnlyClear=True)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# add compatibility with pre-Python 3 version of Labber
if not hasattr(self, 'write_raw'):
self.write_raw = self.write
# add compatibility with pre-1.5.4 version of Labber
if not hasattr(self, 'getTrigChannel'):
self.getTrigChannel = self._getTrigChannel
# start by calling the generic VISA open to make sure we have
# a connection
VISA_Driver.performOpen(self, options)
# check for a strange bug by reading the status bit
try:
status = self.askAndLog('*STB?', bCheckError=False)
status = int(status)
except:
# if conversion to int failed, re-read instrument buffer to
# clear
sBuffer = self.read()
self.log('Extra data read from Tektronix AWG: %s' % sBuffer)
# get model name and number of channels
sModel = self.getModel()
self.nCh = 4 if sModel in ('5004', '5014') else 2
# turn off run mode
self.bIsStopped = False
self._stop()
self.writeAndLog('WLIS:WAV:DEL ALL', bCheckError=False)
self.writeAndLog('SLIS:SUBS:DEL ALL', bCheckError=False)
self.bFastSeq = False
self.bSubSeq = False
self._clear_all()
for n in range(self.nCh):
self.createWaveformOnTek(n + 1, 0, bOnlyClear=True)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# fix issue with termination for read
visa.vpp43.set_attribute(self.com.vi, visa.VI_ATTR_SUPPRESS_END_EN, visa.VI_FALSE)
self.detectedOptions = self.getOptions()
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# fix issue with termination for read
visa.vpp43.set_attribute(self.com.vi, visa.VI_ATTR_SUPPRESS_END_EN, visa.VI_FALSE)
#Detect options: (vector) magnet and swicth heater
detectedOptions = []
rate = self.askAndLog('READ:SYS:VRM:RFMX').strip().rsplit(':',1)[1][1:-1].translate(None,string.letters+"/").split()
if float(rate[0]) > 0:
detectedOptions.append("x magnet")
if float(rate[1]) > 0:
detectedOptions.append("y magnet")
if float(rate[2]) > 0:
detectedOptions.append("z magnet")
heater = self.askAndLog('READ:SYS:VRM:SWHT').strip().rsplit(':',1)[1][1:-1].split()
if heater[0] != "NOSW" or heater[1] != "NOSW" or heater[2] != "NOSW":
detectedOptions.append("switch heater")
self.instrCfg.setInstalledOptions(detectedOptions)
# Make sure that the coordinate system matches the device
coordFunc = self.instrCfg.getQuantity('CoordSys')
v = self.performGetValue(coordFunc)
coordFunc.setValue(v)
def performGetValue(self, quant, options={}):
self.log('performGetValue called: ' + quant.name)
if quant.name.startswith('Measure '):
#Determine which variables are being measured
quantDict = {'Measure Current':'CURR', \
'Measure Voltage':'VOLT', \
'Measure Resistance':'RES'}
reply = VISA_Driver.askAndLog(self, 'FUNC?')
if quantDict[quant.name] in reply:
return True
else:
return False
elif quant.name.endswith('variable'):
#Have set up format so the read or fetch command always returns values in the following order
quantDict = {'Voltage variable':0, \
'Current variable':1, \
'Resistance variable':2}
#If this is first measurement call, perform read operation and return appropriate values
if self.isFirstCall(options):
reply = VISA_Driver.askAndLog(self, 'READ?')
#otherwise perform fetch operation and return appropriate values
else:
reply = VISA_Driver.askAndLog(self, 'FETCH?')
value = reply.split(',')
return value[quantDict[quant.name]]
else:
return VISA_Driver.performGetValue(self, quant, options)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options)
# check for strange bug by reading the status bit
try:
status = self.askAndLog('*STB?', bCheckError=False)
status = int(status)
except:
# if conversion to int failed, re-read instrument buffer to clear
sBuffer = self.read()
self.log('Extra data read from Tek: %s, %s' % (str(status), sBuffer))
# get model name and number of channels
sModel = self.getModel()
self.nCh = 4 if sModel in ('5004', '5014') else 2
# turn off run mode
self.writeAndLog(':AWGC:STOP;')
# init vectors with old values
self.bWaveUpdated = False
self.nOldSeq = -1
self.lOldU16 = [[np.array([], dtype=np.uint16) \
for n1 in range(self.nCh)] for n2 in range(1)]
# clear old waveforms
self.lInUse = [False]*self.nCh
for n in range(self.nCh):
self.createWaveformOnTek(n+1, 0, bOnlyClear=True)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
#Detect options: (vector) magnet and swicth heater
detectedOptions = []
rate = self.askAndLog('READ:SYS:VRM:RFMX').strip().rsplit(
':', 1)[1][1:-1].translate(None, string.letters + "/").split()
if float(rate[0]) > 0:
detectedOptions.append("x magnet")
if float(rate[1]) > 0:
detectedOptions.append("y magnet")
if float(rate[2]) > 0:
detectedOptions.append("z magnet")
heater = self.askAndLog('READ:SYS:VRM:SWHT').strip().rsplit(
':', 1)[1][1:-1].split()
if heater[0] != "NOSW" or heater[1] != "NOSW" or heater[2] != "NOSW":
detectedOptions.append("switch heater")
self.instrCfg.setInstalledOptions(detectedOptions)
# Make sure that the coordinate system matches the device
coordFunc = self.instrCfg.getQuantity('CoordSys')
v = self.performGetValue(coordFunc)
coordFunc.setValue(v)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# keep track of sweep state
self.is_sweeping = False
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# always get function and range: they are essential for correct resolution and sweeping
self.readValueFromOther('Function')
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# Check if there really is an IPS120 at the other end of the wire
if not "IPS120" in self.askAndLog("V"):
raise InstrumentDriver.CommunicationError("Could not get an identification as IPS120.")
self.writeAndLog("Q4")
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
self.bSweep1 = self.getValue('Channel 1 Autosweep')
self.bSweep2 = self.getValue('Channel 2 Autosweep')
self.bSweep3 = self.getValue('Channel 3 Autosweep')
self.bSweep4 = self.getValue('Channel 4 Autosweep')
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
# check type of quantity
if quant.name in ('Ch1 - Data', 'Ch2 - Data', 'Ch3 - Data', 'Ch4 - Data'):
# traces, get channel
channel = int(quant.name[2])
# check if channel is on
if self.getValue('Ch%d - Enabled' % channel):
# get waveform descriptor data
# sDesc = self.askAndLog('C%d:WF? DESC;' % channel)
self.write('C%d:WF? DESC;' % channel, bCheckError=False)
sDesc = self.read(ignore_termination=True)
# start by finding byte count, skip 9 bytes after
indx = sDesc.find('#9')
sDesc = sDesc[indx+2+9:]
# strip out relevant info
iFirst = struct.unpack('>i', sDesc[124:128])[0]
iLast = struct.unpack('>i', sDesc[128:132])[0]
Voffs = struct.unpack('>f', sDesc[160:164])[0]
Vgain = struct.unpack('>f', sDesc[156:160])[0]
dt = struct.unpack('>f', sDesc[176:180])[0]
nPts = struct.unpack('>i', sDesc[116:120])[0]
# print (iFirst, iLast, Voffs, Vgain, dt, nPts)
#
# do a second call to get data, convert to numpy array
self.write('C%d:WF? DAT1;' % channel, bCheckError=False)
sData = self.read(ignore_termination=True)
head = 16
vData = np.fromstring(sData[(head + iFirst*2):(head + (iLast+1)*2)],
dtype='>h', count=nPts)
value = InstrumentQuantity.getTraceDict(vData*Vgain + Voffs, dt=dt)
else:
# not enabled, return empty array
value = InstrumentQuantity.getTraceDict([])
elif quant.name == 'Trig source':
# trig source, treat seperately
sAns = self.askAndLog('TRSE?').strip()
i1 = sAns.find(',SR,') + 4
i2 = sAns.find(',HT')
# convert response to a number
value = quant.getValueFromCmdString(sAns[i1:i2])
elif quant.name == 'Trig level':
# trig options, get local trig source value
sTrig = self.getCmdStringFromValue('Trig source')
sAns = self.askAndLog('%s:TRLV?' % sTrig).strip()
i1 = sAns.find('V')
value = float(sAns[:i1])
elif quant.name == 'Trig slope':
# trig options, get local trig source value
sTrig = self.getCmdStringFromValue('Trig source')
# update visa commands
quant.set_cmd = '%s:TRSL' % sTrig
# run standard VISA case with updated commands
value = VISA_Driver.performGetValue(self, quant, options)
else:
# for all other cases, call VISA driver
value = VISA_Driver.performGetValue(self, quant, options)
return value
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# Check if there really is an IPS120 at the other end of the wire
if not "IPS120" in self.askAndLog("V"):
raise InstrumentDriver.CommunicationError(
"Could not get an identification as IPS120.")
self.writeAndLog("Q4")
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# add compatibility with pre-python 3 version of Labber
if not hasattr(self, 'write_raw'):
self.write_raw = self.write
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options)
# clear value of waveform
self.setValue('Arb. Waveform', [])
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
# check if set value and in sweep mode
if quant.name in ('Voltage', 'Current'):
# check limits
(dStep, dMax) = self.getMaxValueAndSmallestStep()
if abs(value) > dMax:
# new value out of range, return error
raise Exception(
'New value (%.6g) is out of range (max = %.6g)' %
(value, dMax))
# calculate actual value based on smallest step size
value = dStep * np.round(value / dStep)
# check if sweep mode or output off, if not call generic driver
if sweepRate == 0.0 or (not self.getValue('Output')):
return VISA_Driver.performSetValue(self,
quant,
value,
0.0,
options=options)
# sweep mode, do it here
# get old value to find sweep time and step size
currValue = self.performGetValue(quant)
if value == currValue:
# already at the final value, return
return value
# if sweep range is less than two minimal steps, don't sweep
if abs(value - currValue) < 2.5 * dStep:
return VISA_Driver.performSetValue(self,
quant,
value,
0.0,
options=options)
dSweepTime = abs(value - currValue) / sweepRate
# don't allow sweep times that are shorter than 0.1 s
dSweepTime = max(dSweepTime, 0.1)
sSweepTime = '%.1f' % dSweepTime
sCmd = '*CLS;:PROG:REP 0;' + \
'SLOP %s;' % sSweepTime + \
'INT %s;' % sSweepTime + \
'EDIT:STAR;' + \
':SOUR:LEV %.6E;' % value + \
':PROG:EDIT:END;' + \
':PROG:RUN'
self.is_sweeping = True
VISA_Driver.writeAndLog(self, sCmd)
# return target value
return value
else:
# for all other quantities, call the generic VISA driver
return VISA_Driver.performSetValue(self,
quant,
value,
sweepRate,
options=options)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# check if in DC mode
for n in range(2):
ch = n + 1
wfInfor = self.askAndLog(f'SOUR{ch}:APPL?')
if wfInfor.strip('"').split(',')[0] != 'DC':
self.writeAndLog(f':SOUR{ch}:APPL:DC 1,1,0')
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
try:
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
except Error as e:
# re-cast errors as a generic communication error
msg = str(e)
raise BaseDriver.CommunicationError(msg)
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function
should return the actual value set by the instrument."""
# check quantity name
if quant.name == 'Frequency':
self.write('P%08.fZ0K0L3M0N6O3' % (value / 1000.))
else:
# otherwise, call standard VISA case
VISA_Driver.performSetValue(self, quant, value, sweepRate, options)
return value
def checkIfSweeping(self, quant, options={}):
#Can't create quant instances from here, can only pass name of quant
#Whereas system
if type(quant) == str:
name = quant
else:
name = quant.name
if name == 'Source Voltage Level' or name == 'Source Current Level':
#If sweeping, can't go into program edit mode
#Can't see any other way of checking if program is running
VISA_Driver.writeAndLog(self,'*CLS') #Clear any existing errors
VISA_Driver.writeAndLog(self,'PROG:EDIT:STAR') #force an error if program running
err = VISA_Driver.askAndLog(self,'SYST:ERR?') #Check if there's a 'program running' error
#Separate error code and error message
#error code = 0 -> no errors
errCode = int(err.split(',')[0])
if errCode == -284:
#There is a 'program running' error, so program must be sweeping
return True
elif errCode == 103:
#There is a 'program being edited error' for some reason. Stop editing
self.log("Program didn't stop properly")
VISA_Driver.writeAndLog(self,'PROG:EDIT:END')
return False
else:
VISA_Driver.writeAndLog(self,'PROG:EDIT:END')
return False
else:
#Not checking one of the quants that can sweep
return False
def performStopSweep(self, quant, options={}):
# This command is only necessary if in ramp mode
if quant.name.startswith("Voltage"):
mode = self.getValue("Voltage Mode")
elif quant.name.startswith("Current"):
mode = self.getValue("Voltage Mode")
else:
# if it is some other quant, call default function
VISA_Driver.performStopSweep(self, quant, options)
if mode == "Ramp":
VISA_Driver.writeAndLog(self, "ABOR")
def performClose(self, bError=False, options={}):
"""Perform the close instrument connection operation"""
try:
# try to stop awg before closing communication
for n in range(self.n_ch):
self.writeAndLog(':OUTP%d 0' % (n + 1))
self.stop_awg()
except:
pass
# close VISA connection
VISA_Driver.performClose(self, bError, options)
def performStopSweep(self, quant, options={}):
#This command is only necessary if in ramp mode
if quant.name.startswith('Voltage'):
mode = self.getValue('Voltage Mode')
elif quant.name.startswith('Current'):
mode = self.getValue('Voltage Mode')
else:
#if it is some other quant, call default function
VISA_Driver.performStopSweep(self, quant, options)
if mode == 'Ramp':
VISA_Driver.writeAndLog(self, 'ABOR')
def clearMessages(self):
#Send version request so message buffer isn't empty
VISA_Driver.writeAndLog(self,'V')
#Read message buffer in full, to clear any messages that were not previously cleared
#(Uncleared messages seem to arise from fact that device seems to be comparatively slow to reply)
reply = VISA_Driver.read(self,ignore_termination=True)
self.log("Message buffer read on initialisation: "+reply)
while not reply.startswith('IPS120'):
#There was an error or incorrect value, try to clear message buffer again
reply = VISA_Driver.read(self,ignore_termination=True)
self.wait(delayTime)
self.log("Message buffer read again: "+reply)
def clearMessages(self):
#Send version request so message buffer isn't empty
VISA_Driver.writeAndLog(self, 'V')
#Read message buffer in full, to clear any messages that were not previously cleared
#(Uncleared messages seem to arise from fact that device seems to be comparatively slow to reply)
reply = VISA_Driver.read(self, ignore_termination=True)
self.log("Message buffer read on initialisation: " + reply)
while not reply.startswith('IPS120'):
#There was an error or incorrect value, try to clear message buffer again
reply = VISA_Driver.read(self, ignore_termination=True)
self.wait(delayTime)
self.log("Message buffer read again: " + reply)
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
#This device does not respond to *IDN?, so let's check manually
id = self.askAndLog("ID")
if not id in ("7260", "7265"):
raise InstrumentDriver.CommunicationError(
"ID query did not return 7260 or 7265. Is this the right driver for the device at the right address?"
)
return
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function
should return the actual value set by the instrument."""
# check quantity name
if quant.name == 'Frequency':
self.write('FR%011.0fHZ' % value)
elif quant.name == 'Power':
self.write('LE%+.1fDM' % value)
else:
# otherwise, call standard VISA case
VISA_Driver.performSetValue(self, quant, value, sweepRate, options)
return value
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
# This device does not respond to *IDN?, so let's check manually
id = self.askAndLog("ID")
if not id in ("7260", "7265"):
raise InstrumentDriver.CommunicationError(
"ID query did not return 7260 or 7265. Is this the right driver for the device at the right address?"
)
return
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options=options)
self.amplitude = 0
self.phase = 0
self.IOffset = 0
self.QOffset = 0
self.II = 1
self.IQ = 0
self.QI = 0
self.QQ = 1
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# add compatibility with pre-python 3 version of Labber
if not hasattr(self, 'write_raw'):
self.write_raw = self.write
# Call the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options)
# clear value of waveforms
self.write('SOUR1:DATA:VOL:CLE')
self.write('SOUR2:DATA:VOL:CLE')
self.setValue('Channel 1 Arb. Waveform', [])
self.setValue('Channel 2 Arb. Waveform', [])
self.waves = [None] * 2
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
if quant.name in ('Frequency'):
value = VISA_Driver.performGetValue(
self, quant,
options) / 1e2 # Return value is pad with 0 in the end.
elif quant.name in ('Level', 'Output', 'REF_10M', 'REF_1.6G'):
value = VISA_Driver.performGetValue(
self, quant, options
) # value will be converted according to combo_defs, if there exists.
else:
value = quant.getValue()
return value
def performOpen(self, options={}):
"""Perform the operation of opening the instrument connection"""
# start by calling the generic VISA open to make sure we have a connection
VISA_Driver.performOpen(self, options)
# get model name and number of channels
sModel = self.getModel()
if sModel == '5208':
self.nCh = 8
elif sModel == '5204':
self.nCh = 4
elif sModel == '5202':
self.nCh = 2
self.nMarker = 4
self.initSetConfig()
def performOpen(self, options={}):
VISA_Driver.performOpen(self, options=options)
self.data = None
self.xdisp = 0
self.xincr = 1
self.f1 = 0
self.f2 = 0
self.I1 = None
self.Q1 = None
self.I2 = None
self.Q2 = None
self.P1Mean = None
self.P2Mean = None
self.psi = None
self.covar = None
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should return the actual value set by the instrument"""
if quant.name in ('Range type',):
if quant.getValueString(value) == 'Zero-span mode':
# set span to zero
self.sendValueToOther('Span', 0.0)
self.sendValueToOther('# of points', 2.0)
#sweep time should be set to a small value (for example, 10 ms)
self.writeAndLog(':SWE:TIME 1E-3;')
else:
# set lowest possible span to get out of zero-span mode
if self.getValue('Span') < 10:
self.sendValueToOther('Span', 1000000)
if self.getValue('# of points') == 2:
self.sendValueToOther('# of points', 1001)
# sweep time should be set to auto
self.writeAndLog(':SWE:TIME:AUTO 1;')
elif quant.name in ('Wait for new trace',):
# turn on continous acquisition if not waiting
if value == False:
self.writeAndLog(':INIT:CONT ON;')
elif quant.name in ('Trace type CS', 'Trace type CW', 'Measurement Type'):
pass
else:
# run standard VISA case
value = VISA_Driver.performSetValue(self, quant, value, sweepRate, options)
return value
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
if quant.name in ('Zero-span mode',):
# set span to zero
if value == True:
quantSpan = self.instrCfg.getQuantity('Span')
self.performSetValue(quantSpan, 0.0)
quantPts = self.instrCfg.getQuantity('# of points')
self.performSetValue(quantPts, 2)
# sweep time should be set to a small value (for example, 10 ms)
self.writeAndLog(':SWE:TIME:AUTO 0;:SWE:TIME 10E-3;')
else:
# set lowest possible span to get out of zero-span mode
quantSpan = self.instrCfg.getQuantity('Span')
self.performSetValue(quantSpan, 100.)
# sweep time should be set to auto
self.writeAndLog(':SWE:TIME:AUTO 1;')
elif quant.name in ('Wait for new trace',):
# turn on continous acquisition if not waiting
if value == False:
self.writeAndLog(':INIT:CONT ON;')
else:
# run standard VISA case
value = VISA_Driver.performSetValue(self, quant, value, sweepRate, options)
return value
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
# create new channels if needed
if quant.name in ('S11 - Enabled', 'S21 - Enabled', 'S12 - Enabled',
'S22 - Enabled'):
# get updated list of measurements in use
param = quant.name[:3]
self.getActiveMeasurements()
# clear old measurements for this parameter
if param in self.dMeasParam:
for name in self.dMeasParam[param]:
self.writeAndLog("CALC:PAR:DEL '%s'" % name)
# create new measurement, if enabled is true
if value:
newName = 'LabC_%s' % param
self.writeAndLog("CALC:PAR:SDEF '%s','%s'" % (newName, param))
# show on PNA screen
iTrace = 1 + ['S11', 'S21', 'S12', 'S22'].index(param)
self.writeAndLog("DISP:WIND:TRAC%d:FEED '%s'" % (iTrace, newName))
# add to dict with list of measurements
self.dMeasParam[param] = [newName]
elif quant.name in ('Wait for new trace',):
# do nothing
pass
else:
# run standard VISA case
value = VISA_Driver.performSetValue(self, quant, value, sweepRate, options)
return value
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
# do special case get value for some quantities
if quant.name == 'I Voltage':
return self.getVoltage(1)
elif quant.name == 'Q Voltage':
return self.getVoltage(2)
elif quant.name == 'I Autorange':
return self.getCommand('A', 1)
elif quant.name == 'Q Autorange':
return self.getCommand('A', 2)
elif quant.name == 'I Range':
return self.getCommand('R', 1)
elif quant.name == 'Q Range':
return self.getCommand('R', 2)
elif quant.name == 'I Offset':
return self.IOffset
elif quant.name == 'Q Offset':
return self.QOffset
elif quant.name == 'II':
return self.II
elif quant.name == 'QQ':
return self.QQ
elif quant.name == 'IQ':
return self.IQ
elif quant.name == 'QI':
return self.QI
else:
# run the generic visa driver case
return VISA_Driver.performGetValue(self, quant, options=options)
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
if quant.name == 'Channel 1 Voltage':
self.setVoltage(1, value)
elif quant.name == 'Channel 2 Voltage':
self.setVoltage(2, value)
elif quant.name == 'Channel 3 Voltage':
self.setVoltage(3, value)
elif quant.name == 'Channel 4 Voltage':
self.setVoltage(4, value)
elif quant.name == 'Channel 1 Autosweep':
self.bSweep1 = value
elif quant.name == 'Channel 2 Autosweep':
self.bSweep2 = value
elif quant.name == 'Channel 3 Autosweep':
self.bSweep3 = value
elif quant.name == 'Channel 4 Autosweep':
self.bSweep4 = value
else:
# for all other quantities, call the generic VISA driver
return VISA_Driver.performSetValue(self, quant, value, sweepRate,
options=options)
return value
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
# check type of quantity
if quant.name in ('Ch1 - Data', 'Ch2 - Data', 'Ch3 - Data', 'Ch4 - Data'):
# traces, get channel
channel = int(quant.name[2])
# check if channel is on
if self.getValue('Ch%d - Enabled' % channel):
# select channel and set # of bytes to send
self.write(':DATA:SOU CH%d;:WFMO:BYT_N 2;' % channel, bCheckError=False)
# query range and offset
sRange = self.ask(':WFMO:XZE?;:WFMO:XIN?;:WFMO:YMU?;:WFMO:YOF?;:WFMO:YZE?;', bCheckError=False)
lRange = sRange.split(';')
(t0, dt, gain, ioffset, offset) = [float(s) for s in lRange]
# get data as i16, convert to numpy array
self.write('CURV?', bCheckError=False)
sData = self.read(ignore_termination=True)
# strip header to find # of points
i0 = sData.find('#')
nDig = int(sData[i0+1])
nByte = int(sData[i0+2:i0+2+nDig])
nData = nByte/2
# get data to numpy array
vData = np.frombuffer(sData[(i0+2+nDig):(i0+2+nDig+nByte)],
dtype='>h', count=nData)
value = InstrumentQuantity.getTraceDict( \
gain*(vData - ioffset) + offset, dt=dt)
else:
# not enabled, return empty array
value = InstrumentQuantity.getTraceDict([])
else:
# for all other cases, call VISA driver
value = VISA_Driver.performGetValue(self, quant, options)
return value
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
# perform special getValue for reading complex value
name = str(quant.name)
if name == 'Value':
# get complex value in one instrument reading
sCmd = 'SNAP?1,2'
sAns = self.askAndLog(sCmd).strip()
lData = sAns.split(',')
#Sometimes, we receive the value twice
#(0.12e-3,4.56e-70.12e-3,4.56e-7 instead of 0.12e-3,4.56e-7)
#This is a simple fix:
if len(lData) > 2:
lData = sAns[:len(sAns)/2].split(',')
#Also, sometimes we receive an additional "-" at the end of a value
#(0.12e-3,4.56e-7- instead of 0.12e-3,4.56e-7)
#Hence, another simple fix:
if lData[1][-1] == "-":
lData[1] = ldata[1][:-1]
# return complex values
return complex(float(lData[0].strip()), float(lData[1].strip()))
else:
# run the generic visa driver case
return VISA_Driver.performGetValue(self, quant, options=options)
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
if (quant.datatype == quant.DOUBLE):
value = self.askAndLog(quant.set_cmd+"?")
value = value.replace(" ", "")
for i,c in enumerate(value):
if not c in "0123456789.-eE":
break
number=float(value[:i])
unit=value[i:]
factor = 1
cfactor = unit[:1]
if (cfactor == "G"):
factor = 1e9
elif (cfactor == "M"):
factor = 1e6
elif (cfactor == "k"):
factor = 1e3
elif (cfactor == "m"):
factor = 1e-3
elif (cfactor == "u"):
factor = 1e-6
elif (cfactor == "n"):
factor = 1e-9
elif (cfactor == "p"):
factor = 1e-12
v = float(number)*factor
return v
else:
value = VISA_Driver.performGetValue(self, quant, options)
return value
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
# perform special setValue for delay commands
name = str(quant.name)
if name.endswith(('Start time', 'Start reference',
'Stop time', 'Stop reference')):
# get pulse channel in use
lName = name.split(' ')
key = '%s - %s' % (lName[0], lName[2])
sChannel = '%d' % self.dChCmd[key]
# get buddy quantity
if lName[3] == 'time':
sTime = quant.getCmdStringFromValue(value)
sRef = self.getCmdStringFromValue('%s - %s reference' %
(lName[0], lName[2]))
else:
sTime = self.getCmdStringFromValue('%s - %s time' %
(lName[0], lName[2]))
sRef = quant.getCmdStringFromValue(value)
sCmd = 'DLAY %s,%s,%s' % (sChannel, sRef, sTime)
self.writeAndLog(sCmd)
return value
else:
# for all other quantities, call the generic VISA driver
return VISA_Driver.performSetValue(self, quant, value, sweepRate,
options=options)
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
# if quant.name in ('Zero-span mode',):
if quant.name in ('Range type', ):
if quant.getValueString(value) == 'Zero-span mode':
# set span to zero
self.sendValueToOther('Span', 0.0)
self.sendValueToOther('# of points', 2.0)
# sweep time should be set to a small value (for example, 10 ms)
self.writeAndLog(':SWE:TIME:AUTO 0;:SWE:TIME 10E-3;')
else:
# set lowest possible span to get out of zero-span mode
self.sendValueToOther('Span', 100.0)
# sweep time should be set to auto
self.writeAndLog(':SWE:TIME:AUTO 1;')
elif quant.name in ('Wait for new trace', ):
# turn on continous acquisition if not waiting
if value == False:
self.writeAndLog(':INIT:CONT ON;')
else:
# run standard VISA case
value = VISA_Driver.performSetValue(self, quant, value, sweepRate,
options)
return value
def performGetValue(self, quant, options={}):
"""Perform the Get Value instrument operation"""
# perform special getValue for reading complex value
name = str(quant.name)
if name == 'Value':
# get complex value in one instrument reading
sCmd = 'SNAP?1,2'
sAns = self.askAndLog(sCmd).strip()
lData = sAns.split(',')
#Sometimes, we receive the value twice
#(0.12e-3,4.56e-70.12e-3,4.56e-7 instead of 0.12e-3,4.56e-7)
#This is a simple fix:
if len(lData) > 2:
lData = sAns[:int(len(sAns)/2)].split(',')
#Also, sometimes we receive an additional "-" at the end of a value
#(0.12e-3,4.56e-7- instead of 0.12e-3,4.56e-7)
#Hence, another simple fix:
if lData[1][-1] == "-":
lData[1] = ldata[1][:-1]
# return complex values
return complex(float(lData[0].strip()), float(lData[1].strip()))
else:
# run the generic visa driver case
return VISA_Driver.performGetValue(self, quant, options=options)
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the set value operation"""
# check type of quantity: There seems to be a problem with some float type commands... (i.e. oscillator frequency) Use the fixed point version instead.
if quant.name in ("Oscillator Frequency"):
self.writeAndLog(quant.set_cmd + " " + str(int(value * 1000))) # Fixed point version uses mHz
else:
return VISA_Driver.performSetValue(self, quant, value, sweepRate, options=options)
return value
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
# if quant.name == 'blah':
# self.dsa. _set(value)
# else:
# for all other quantities, call the generic VISA driver
return VISA_Driver.performSetValue(self, quant, value, sweepRate, options=options)
def performOpen(self, options={"values_format":visa.single | visa.big_endian}):
"""Perform the operation of opening the instrument connection"""
try:
VISA_Driver.performOpen(self, options=options) # start by calling the generic VISA open to make sure we have a connection
self.com.values_format=visa.single | visa.big_endian #this sets this bit order so we can interpret the binary data
self.writeAndLog("HEADER OFF") #having the header on makes reading data more difficult
self.writeAndLog("DATA:ENCDG FPBinary") # enable the encoding of bits we can understand (faster data transfer than ASCII)
self.AvgTrace = {'Time': None, #This is a local dictionary to avoid taking a sweep twice unnecessarily
'Amplitude': None,
'RollAvg Time': None,
'RollAvg Amplitude': None}
self.numRep=self.getValue("Number of shifts")
except Error as e:
# re-cast errors as a generic communication error
msg = str(e)
raise InstrumentDriver.CommunicationError(msg)
def performOpen(self, options={}):
""" Perform the operation of opening the instrument connection """
# self.writeAndLog('*CLS')
VISA_Driver.performOpen(self, options=options)
self.writeAndLog("*CLS")
self.writeAndLog("OUTX0") # set output to GPIB
self.writeAndLog("PDST 3") # set Print/Plot/Dump destination to GPIB
self.writeAndLog("DISP 2, 1") # set displays live
self.writeAndLog("DFMT 1") # set displays to dual display
self.writeAndLog("ACTD 0") # set active display to displayA
self.writeAndLog("RPMF 0") # set Hz as frequency units (not RPM)
self.writeAndLog("A1RG 1") # Autoranges Channel 1
self.writeAndLog("A2RG 1") # Autoranges Channel 2
self.writeAndLog("I1AR 1") # Autotracks Channel 1
self.writeAndLog("I2AR 1") # Autotracks Channel 2
self.writeAndLog("ASCL 0") # Autoscales Display 0
self.writeAndLog("ASCL 1") # Autoscales Display 1
self.writeAndLog("STRT") # Starts measurement
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
if quant.name == 'Number of shifts':
self.numRep= value
else:
# for all other quantities, call the generic VISA driver
value = VISA_Driver.performSetValue(self, quant, value, sweepRate, options=options)
return value
def performSetValue(self, quant, value, sweepRate=0.0, options={}):
"""Perform the Set Value instrument operation. This function should
return the actual value set by the instrument"""
# update visa commands for triggers
if quant.name in ('S11 - Enabled', 'S21 - Enabled', 'S12 - Enabled',
'S22 - Enabled'):
if self.getModel() in ('E5071C',):
# new trace handling, use trace numbers, set all at once
lParam = ['S11', 'S21', 'S12', 'S22']
dParamValue = dict()
for param in lParam:
dParamValue[param] = self.getValue('%s - Enabled' % param)
dParamValue[quant.name[:3]] = value
# add parameters, if enabled
self.dMeasParam = dict()
for (param, enabled) in dParamValue.items():
if enabled:
nParam = len(self.dMeasParam)+1
self.writeAndLog(":CALC:PAR%d:DEF %s" %
(nParam, param))
self.dMeasParam[param] = nParam
# set number of visible traces
self.writeAndLog(":CALC:PAR:COUN %d" % len(self.dMeasParam))
else:
# get updated list of measurements in use
self.getActiveMeasurements()
param = quant.name[:3]
# old-type handling of traces
if param in self.dMeasParam:
# clear old measurements for this parameter
for name in self.dMeasParam[param]:
self.writeAndLog("CALC:PAR:DEL '%s'" % name)
# create new measurement, if enabled is true
if value:
newName = 'LabC_%s' % param
self.writeAndLog("CALC:PAR:EXT '%s','%s'" % (newName, param))
# show on PNA screen
iTrace = 1 + ['S11', 'S21', 'S12', 'S22'].index(param)
# sPrev = self.askAndLog('DISP:WIND:CAT?')
# if sPrev.find('EMPTY')>0:
# # no previous traces
# iTrace = 1
# else:
# # previous traces, add new
# lTrace = sPrev[1:-1].split(',')
# iTrace = int(lTrace[-1]) + 1
self.writeAndLog("DISP:WIND:TRAC%d:FEED '%s'" % (iTrace, newName))
# add to dict with list of measurements
self.dMeasParam[param] = [newName]
elif quant.name in ('Wait for new trace',):
# do nothing
pass
else:
# run standard VISA case
value = VISA_Driver.performSetValue(self, quant, value, sweepRate, options)
return value
