def measureImpulseResponse(fpga,
scope,
baseline,
pulse,
dacoffsettime=6,
pulselength=1):
"""Measure the response to a DAC pulse
fpga: connected fpga server
scope: connected scope server
dac: 'a' or 'b'
returns: list
list[0] : start time (s)
list[1] : time step (s)
list[2:]: actual data (V)
"""
#units clock cycles
dacoffsettime = int(round(dacoffsettime))
triggerdelay = 30
looplength = 2000
pulseindex = triggerdelay - dacoffsettime
scope.start_time(Value(triggerdelay, 'ns'))
#calculate the baseline voltage by capturing a trace without a pulse
data = np.resize(baseline, looplength)
data[pulseindex:pulseindex + pulselength] = pulse
data[0] |= trigger
fpga.dac_run_sram(data.astype('u4'), True)
data = (scope.get_trace(1))
data[0] -= Value(triggerdelay * 1e-9,
'V') # TODO: not sure about units here--pjjo
return (data)
def get_trace(self, c, channel, start=1, stop=5000):
"""Get a trace from the scope.
OUTPUT - (array voltage in volts, array time in seconds)
"""
## DATA ENCODINGS
## RIB - signed, MSB first
## RPB - unsigned, MSB first
## SRI - signed, LSB first
## SRP - unsigned, LSB first
wordLength = 4 #Hardcoding to set data transer word length to 2 bytes
recordLength = stop - start + 1
dev = self.selectedDevice(c)
#DAT:SOU - set waveform source channel
yield dev.write('DAT:SOU CH%d' % channel)
print '11111111'
#DAT:ENC - data format (binary/ascii)
yield dev.write('DAT:ENC RIB')
#Set number of bytes per point
yield dev.write('DAT:WID %d' % wordLength)
print '222222'
#Starting and stopping point
yield dev.write('DAT:STAR %d' % start)
yield dev.write('DAT:STOP %d' % stop)
print '333333333'
#Transfer waveform preamble
position = yield dev.query('CH%d:POSITION?' %
channel) # in units of divisions
position = position.strip().split(' ')[0]
#Transfer waveform data
binary = yield dev.query('CURV?')
#Parse waveform preamble
# preamble = yield dev.query('WFMO?')
# voltsPerDiv, secPerDiv, voltUnits, timeUnits = _parsePreambleWFMO(preamble)
# print voltsPerDiv, secPerDiv, voltUnits, timeUnits
voltsPerDiv = yield dev.query('CH%d:SCA?' % channel)
voltsPerDiv = float(voltsPerDiv.strip()[voltsPerDiv.index('SCALE') +
5:])
secPerDiv = yield dev.query('HOR:MAI:SCA?')
secPerDiv = float(secPerDiv.strip()[secPerDiv.index('SCALE') + 5:])
voltUnits = 'V'
timeUnits = 's'
voltUnitScaler = Value(
1, voltUnits)['mV'] # converts the units out of the scope to mV
timeUnitScaler = Value(1, timeUnits)['ns']
#Parse binary
# trace = _parseBinaryData(binary,wordLength = wordLength)
print 'trace: ', trace[:20]
trace = numpy.fromstring(binary[13:-1], dtype='<u4')
#Convert from binary to volts
traceVolts = (trace * (1 / 2.**31) * VERT_DIVISIONS / 2 * voltsPerDiv -
float(position) * voltsPerDiv) * voltUnitScaler
time = numpy.linspace(0, HORZ_DIVISIONS * secPerDiv * timeUnitScaler,
len(traceVolts)) #recordLength)
returnValue((time, traceVolts))
def calibrateDCPulse(cxn, boardname, channel):
reg = cxn.registry
reg.cd(['', keys.SESSIONNAME, boardname])
fpga = cxn[FPGA_SERVER_NAME]
fpga.select_device(boardname)
dac_baseline = -0x2000
dac_pulse = 0x1FFF
dac_neutral = 0x0000
if channel:
pulse = makeSample(dac_neutral, dac_pulse)
baseline = makeSample(dac_neutral, dac_baseline)
else:
pulse = makeSample(dac_pulse, dac_neutral)
baseline = makeSample(dac_baseline, dac_neutral)
#Set up the scope
scope = cxn.sampling_scope
scopeID = reg.get(keys.SCOPEID)
print "scopeID:", scopeID
p = scope.packet().\
select_device(scopeID).\
reset().\
channel(reg.get(keys.SSCOPECHANNEL, True, 2)).\
trace(1).\
record_length(5120).\
average(128).\
sensitivity(reg.get(keys.SSCOPESENSITIVITYDC, True, 200*labrad.units.mV)).\
offset(Value(0,'mV')).\
time_step(Value(5,'ns')).\
trigger_level(Value(0.18,'V')).\
trigger_positive()
p.send()
offsettime = reg.get(keys.TIMEOFFSET)
print 'Measuring step response...'
trace = measureImpulseResponse(fpga,
scope,
baseline,
pulse,
dacoffsettime=offsettime['ns'],
pulselength=100)
trace = trace[trace.unit] # strip units
# set the output to zero so that the fridge does not warm up when the
# cable is plugged back in
fpga.dac_run_sram([makeSample(dac_neutral, dac_neutral)] * 20, False)
ds = cxn.data_vault
ds.cd(['', keys.SESSIONNAME, boardname], True)
dataset = ds.new(keys.CHANNELNAMES[channel], [('Time', 'ns')],
[('Voltage', '', 'V')])
ds.add_parameter(keys.TIMEOFFSET, offsettime)
ds.add(
np.transpose([
1e9 * (trace[0] + trace[1] * np.arange(np.alen(trace) - 2)),
trace[2:]
]))
return (datasetNumber(dataset))
def connect(self, server, port):
"""Connect to a device"""
print("Connecting to '%s' on port '%s'" % (server.name, port))
self.server = server
self.ctx = server.context()
self.port = port
p = self.packet()
p.open(port)
print("opened on port '%s'" % port)
self.baud = 9600
self.timeout = Value(2, 's')
self.parity = 'E'
self.data_bits = 7
self.stop_bits = 1
p.baudrate(self.baud) # set BAUDRATE
p.read() # clear buffer
p.timeout(self.timeout) # sets timeout
p.parity(self.parity)
p.bytesize(self.data_bits)
p.stopbits(self.stop_bits)
print("Connected.")
yield p.send()
def zero(anr, spec, fpga, freq):
"""Calibrates the zeros for DAC A and B using the spectrum analyzer"""
yield anr.frequency(Value(freq, 'GHz'))
yield spectFreq(spec, freq)
a = 0
b = 0
precision = 0x800
print ' calibrating at %g GHz...' % freq
while precision > 0:
al = yield measurePower(spec, fpga, a - precision, b)
ar = yield measurePower(spec, fpga, a + precision, b)
ac = yield measurePower(spec, fpga, a, b)
corra = long(round(precision * minPos(al, ac, ar)))
a += corra
#print a
bl = yield measurePower(spec, fpga, a, b - precision)
br = yield measurePower(spec, fpga, a, b + precision)
bc = yield measurePower(spec, fpga, a, b)
corrb = long(round(precision * minPos(bl, bc, br)))
b += corrb
optprec = 2 * np.max([abs(corra), abs(corrb)])
precision /= 2
if precision > optprec:
precision = optprec
print ' a = %4d b = %4d uncertainty : %4d, power %6.1f dBm' % \
(a, b, precision, 10 * np.log(bc) / np.log(10.0))
returnValue([a, b])
def doSwitch(self, c, channel):
cxn = self.client
if type(c['device']['bits'][channel])==IntType:
yield cxn[c['device']['server']].sequence([\
(c['device']['bits'][channel], True, Value(c['device']['delay'],'s')),
(c['device']['bits'][channel], False, Value(c['device']['delay'],'s'))])
elif type(c['device']['bits'][channel])==ListType:
# start assembling the multi-switch sequence
seq = []
# open all darlington switches but the last one without any delays
for i in range(len(c['device']['bits'][channel])-1):
seq.append((c['device']['bits'][channel][i], True, Value(0,'s')))
# add a delay to the last one so that the mechanical switch can actuate once it has sufficient current
seq.append((c['device']['bits'][channel][len(c['device']['bits'][channel])-1], True, Value(c['device']['delay'],'s')))
# close all the darlington switches afterwards
for i in range(len(c['device']['bits'][channel])-1):
seq.append((c['device']['bits'][channel][i], False, Value(0,'s')))
seq.append((c['device']['bits'][channel][len(c['device']['bits'][channel])-1], False, Value(c['device']['delay'],'s')))
yield cxn[c['device']['server']].sequence(seq)
def trigger_level(self, c, level = None):
"""Get or set the vertical zero position of a channel in voltage
"""
dev = self.selectedDevice(c)
if level is None:
resp = yield dev.query(':TRIG:EDGE:LEV?')
else:
yield dev.write((':TRIG:EDGE:LEV %f') %level['V'])
resp = yield dev.query(':TRIG:EDGE:LEV?')
level = Value(float(resp),'V')
returnValue(level)
def scale(self, c, channel, scale = None):
"""Get or set the vertical scale per div of a channel in Volts
"""
dev = self.selectedDevice(c)
if scale is None:
resp = yield dev.query(':CHAN%d:SCAL?' %channel)
else:
scale = format(scale['V'],'E')
yield dev.write((':CHAN%d:SCAL '+scale+' V') %channel)
resp = yield dev.query(':CHAN%d:SCAL?' %channel)
scale = (Value(float(resp),'V'))
returnValue(scale)
def get_trace(self, c, channel, start=1, stop=10000):
"""Get a trace from the scope.
OUTPUT - (array voltage in volts, array time in seconds)
"""
## DATA ENCODINGS
## RIB - signed, MSB first
## RPB - unsigned, MSB first
## SRI - signed, LSB first
## SRP - unsigned, LSB first
wordLength = 2 #Hardcoding to set data transer word length to 2 bytes
recordLength = stop-start+1
dev = self.selectedDevice(c)
#DAT:SOU - set waveform source channel
yield dev.write('DAT:SOU CH%d' %channel)
#DAT:ENC - data format (binary/ascii)
yield dev.write('DAT:ENC RIB')
#Set number of bytes per point
yield dev.write('DAT:WID %d' %wordLength)
#Starting and stopping point
yield dev.write('DAT:STAR %d' %start)
yield dev.write('DAT:STOP %d' %stop)
#Transfer waveform preamble
preamble = yield dev.query('WFMP?')
position = yield dev.query('CH%d:POSITION?' %channel) # in units of divisions
#Transfer waveform data
binary = yield dev.query('CURV?')
#Parse waveform preamble
voltsPerDiv, secPerDiv, voltUnits, timeUnits = _parsePreamble(preamble)
voltUnitScaler = Value(1, voltUnits)['mV'] # converts the units out of the scope to mV
timeUnitScaler = Value(1, timeUnits)['ns']
#Parse binary
trace = _parseBinaryData(binary,wordLength = wordLength)
#Convert from binary to volts
traceVolts = (trace * (1/32768.0) * VERT_DIVISIONS/2 * voltsPerDiv - float(position) * voltsPerDiv) * voltUnitScaler
time = numpy.linspace(0, HORZ_DIVISIONS * secPerDiv * timeUnitScaler,len(traceVolts))#recordLength)
returnValue((time, traceVolts))
def connect(self, server, port):
"""Connect to a device."""
print 'connecting to "%s" on port "%s"...' % (server.name, port),
self.server = server
self.ctx = server.context()
self.port = port
p = self.packet()
TIMEOUT = Value(5, 's')
BAUD = 115200
p.open(port)
p.baudrate(BAUD)
p.read() # clear out the read buffer
p.timeout(TIMEOUT)
print(" CONNECTED ")
yield p.send()
def sideband(anr, spect, fpga, corrector, carrierfreq, sidebandfreq):
"""When the IQ mixer is used for sideband mixing, imperfections in the
IQ mixer and the DACs give rise to a signal not only at
carrierfreq+sidebandfreq but also at carrierfreq-sidebandfreq.
This routine determines amplitude and phase of the sideband signal
for carrierfreq-sidebandfreq that cancels the undesired sideband at
carrierfreq-sidebandfreq."""
reserveBuffer = corrector.dynamicReserve
corrector.dynamicReserve = 4.0
if abs(sidebandfreq) < 3e-5:
returnValue(0.0j)
yield anr.frequency(Value(carrierfreq, 'GHz'))
comp = 0.0j
precision = 1.0
yield spectFreq(spect, carrierfreq - sidebandfreq)
while precision > 2.0**-14:
lR = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq,
sidebandfreq, comp - precision)
rR = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq,
sidebandfreq, comp + precision)
cR = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq,
sidebandfreq, comp)
corrR = precision * minPos(lR, cR, rR)
comp += corrR
lI = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq,
sidebandfreq,
comp - 1.0j * precision)
rI = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq,
sidebandfreq,
comp + 1.0j * precision)
cI = yield measureOppositeSideband(spect, fpga, corrector, carrierfreq,
sidebandfreq, comp)
corrI = precision * minPos(lI, cI, rI)
comp += 1.0j * corrI
precision = np.min(
[2.0 * np.max([abs(corrR), abs(corrI)]), precision / 2.0])
print ' compensation: %.4f%+.4fj +- %.4f, opposite sb: %6.1f dBm' % \
(np.real(comp), np.imag(comp), precision, 10.0 * np.log(cI) / np.log(10.0))
corrector.dynamicReserve = reserveBuffer
print '@@@@@@@@@@@@@@@'
returnValue(comp)
def connect(self, server, port):
"""Connect to a device"""
print("Connecting to '%s' on port '%s'" % (server.name, port))
self.server = server
self.ctx = server.context()
self.port = port
p = self.packet()
p.open(port)
print("opened on port '%s'" % port)
self.BAUDRATE = 115200
self.TIMEOUT = Value(5, 's')
p.baudrate(self.BAUDRATE) # set BAUDRATE
p.read() # clear buffer
p.timeout(self.TIMEOUT) # sets timeout
print("Connected.")
yield p.send()
def measure(self, c, count=0, wait=Value(0.5, 's')):
''' returns the values from the measure function of the scope. if count >0, wait until
scope has >= count stats before returning, waiting _wait_ time between calls.
Note that the measurement must be set manually on the scope for this to work. '''
dev = self.selectedDevice(c)
yield dev.write(":MEAS:STAT ON")
def parse(s):
s = s.split(',')
d = []
while s:
d += [[s[0]] + [float(x) for x in s[1:7]]]
s = s[7:]
return d
d = []
while True:
d = yield dev.query(":MEAS:RES?")
d = parse(d)
counts = [x[-1] for x in d]
if min(counts) >= count:
break
yield util.wakeupCall(wait['s'])
returnValue(d)
def sidebandScanCarrier(cxn,
scanparams,
boardname,
corrector,
use_switch=True):
"""Determines relative I and Q amplitudes by canceling the undesired
sideband at different sideband frequencies."""
reg = cxn.registry
reg.cd(['', keys.SESSIONNAME, boardname])
fpga = cxn[FPGA_SERVER_NAME]
fpga.select_device(boardname)
uwaveSourceID = reg.get(keys.ANRITSUID)
uwaveSource = microwaveSourceServer(cxn, uwaveSourceID)
spec = cxn.spectrum_analyzer_server
ds = cxn.data_vault
spectID = reg.get(keys.SPECTID)
spec.select_device(spectID)
spectInit(spec)
assertSpecAnalLock(spec, spectID)
uwaveSourcePower = reg.get(keys.ANRITSUPOWER)
if use_switch:
cxn.microwave_switch.switch(boardname)
uwaveSource.select_device(uwaveSourceID)
uwaveSource.amplitude(uwaveSourcePower)
uwaveSource.output(True)
print 'Sideband calibration from %g GHz to %g GHz in steps of %g GHz...' \
% (scanparams['carrierMin'],scanparams['carrierMax'],
scanparams['sidebandCarrierStep'])
sidebandfreqs = (np.arange(scanparams['sidebandFreqCount']) \
- (scanparams['sidebandFreqCount']-1) * 0.5) \
* validSBstep(scanparams['sidebandFreqStep'])
dependents = []
for sidebandfreq in sidebandfreqs:
dependents += [('relative compensation', 'Q at f_SB = %g MHz' % \
(sidebandfreq*1e3),''),
('relative compensation', 'I at f_SB = %g MHz' % \
(sidebandfreq*1e3),'')]
ds.cd(['', keys.SESSIONNAME, boardname], True)
dataset = ds.new(keys.IQNAME, [('Antritsu Frequency', 'GHz')], dependents)
ds.add_parameter(keys.ANRITSUPOWER, (reg.get(keys.ANRITSUPOWER)))
ds.add_parameter('Sideband frequency step',
Value(scanparams['sidebandFreqStep'] * 1e3, 'MHz'))
ds.add_parameter('Number of sideband frequencies',
scanparams['sidebandFreqCount'])
freq = scanparams['carrierMin']
while freq < scanparams['carrierMax'] + \
0.001 * scanparams['sidebandCarrierStep']:
print ' carrier frequency: %g GHz' % freq
datapoint = [freq]
for sidebandfreq in sidebandfreqs:
print ' sideband frequency: %g GHz' % sidebandfreq
comp = sideband(uwaveSource, spec, fpga, corrector, freq,
sidebandfreq)
datapoint += [np.real(comp), np.imag(comp)]
ds.add(datapoint)
freq += scanparams['sidebandCarrierStep']
uwaveSource.output(False)
spectDeInit(spec)
if use_switch:
cxn.microwave_switch.switch(0)
return (datasetNumber(dataset))
[startup]
cmdline = %PYTHON% %FILE%
timeout = 20
[shutdown]
message = 987654321
timeout = 20
### END NODE INFO
"""
from labrad.types import Value
from labrad.devices import DeviceServer, DeviceWrapper
from labrad.server import setting
from twisted.internet.defer import inlineCallbacks, returnValue
TIMEOUT = Value(1.0, 's')
class TTLDevice(DeviceWrapper):
@inlineCallbacks
def connect(self, server, port):
"""Connect to a TTL device."""
print 'connecting to "%s" on port "%s"...' % (server.name, port),
self.server = server
self.ctx = server.context()
self.port = port
p = self.packet()
p.open(port)
p.baudrate(57600)
p.read() # clear out the read buffer
p.timeout(TIMEOUT)
[startup]
cmdline = %PYTHON% %FILE%
timeout = 5
[shutdown]
message = 987654321
timeout = 5
### END NODE INFO
"""
from labrad.types import Value
from labrad.devices import DeviceServer, DeviceWrapper
from labrad.server import setting
from twisted.internet.defer import inlineCallbacks, returnValue
TIMEOUT = Value(5.0, 's')
API = {
# name type write read
'channel': (int, 'C{}\n', 'C?\n'), # Select channel
'frequency': (float, 'f{:.8f}\n', 'f?\n'), # Frequency in MHz
'power': (float, 'W{:.3f}\n', 'W?\n'), # Power in dBm
'calibrated': (bool, None, 'V\n'),
'temp_comp_mode': (int, 'Z{}\n', 'Z?\n'),
'vga_dac': (int, 'a{}\n', 'a?\n'), # VGA DAC value [0, 45000]
'phase_step': (float, '~{:.3f}\n', '~?\n'), # Phase step in degrees
'rf_enable': (bool, 'h{}\n', 'h?\n'),
'pa_power_on': (bool, 'r{}\n', 'r?\n'),
'pll_power_on': (bool, 'E{}\n', 'E?\n'),
'model_type': (str, None, '+\n'), # Model type
'serial_number': (int, None, '-\n'), # Serial number
def sidebandScanCarrier(cxn, scanparams, boardname, corrector):
"""Determines relative I and Q amplitudes by canceling the undesired
sideband at different sideband frequencies."""
fpga = cxn.ghz_fpgas
yield fpga.select_device(boardname)
spec = cxn.spectrum_analyzer_server
scope = cxn.tektronix_dsa_8300_sampling_scope
ds = cxn.data_vault
reg = cxn.registry
yield reg.cd(['', keys.SESSIONNAME, boardname])
spectID = yield reg.get(keys.SPECTID)
spec.select_device(spectID)
yield spectInit(spec)
anritsuID = yield reg.get(keys.ANRITSUID)
anritsuPower = yield reg.get(keys.ANRITSUPOWER)
#yield cxn.microwave_switch.switch(boardname)
anr = yield findServer(cxn, anritsuID)
yield anr.select_device(anritsuID)
yield anr.amplitude(anritsuPower)
yield anr.output(True)
print 'Sideband calibration from %g GHz to %g GHz in steps of %g GHz...' \
% (scanparams['carrierMin'],scanparams['carrierMax'],
scanparams['sidebandCarrierStep'])
sidebandfreqs = (np.arange(scanparams['sidebandFreqCount']) \
- (scanparams['sidebandFreqCount']-1) * 0.5) \
* validSBstep(scanparams['sidebandFreqStep'])
# sidebandfreqs = [-0.325, -0.275, -0.225, -0.175, -0.125, -0.075, -0.025, 0.025, 0.075, 0.125, 0.175, 0.225, 0.275, 0.325] 20120411 LjHe
dependents = []
for sidebandfreq in sidebandfreqs:
dependents += [('relative compensation', 'Q at f_SB = %g MHz' % \
(sidebandfreq*1e3),''),
('relative compensation', 'I at f_SB = %g MHz' % \
(sidebandfreq*1e3),'')]
yield ds.cd(['', keys.SESSIONNAME, boardname], True)
dataset = yield ds.new(keys.IQNAME, [('Antritsu Frequency', 'GHz')],
dependents)
yield ds.add_parameter(keys.ANRITSUPOWER,
(yield reg.get(keys.ANRITSUPOWER)))
yield ds.add_parameter('Sideband frequency step',
Value(scanparams['sidebandFreqStep'] * 1e3, 'MHz'))
yield ds.add_parameter('Number of sideband frequencies',
scanparams['sidebandFreqCount'])
freq = scanparams['carrierMin']
while freq < scanparams['carrierMax'] + \
0.001 * scanparams['sidebandCarrierStep']:
print ' carrier frequency: %g GHz' % freq
datapoint = [freq]
for sidebandfreq in sidebandfreqs:
print ' sideband frequency: %g GHz' % sidebandfreq
comp = yield sideband(anr, spec, fpga, corrector, freq,
sidebandfreq)
datapoint += [np.real(comp), np.imag(comp)]
yield ds.add(datapoint)
freq += scanparams['sidebandCarrierStep']
yield anr.output(False)
yield spectDeInit(spec)
#yield cxn.microwave_switch.switch(0)
returnValue(datasetNumber(dataset))
def to_type(value,type_):
if type_.startswith('.'):return Value(value,type_[1:])
if type_ in ['string','str','s'] : return str(value)
if type_ in ['float','f','v',''] : return float(value)
if type_ in ['integer','int','i'] : return int(value)
return Value(value,type_)
def toFloat(num, units):
if hasattr(num, 'unit'):
return num[units]
elif isinstance(num, tuple):
return Value(*num)[units]
return num
def get_trace(self,
c,
channel,
start=1,
stop=16000,
record_length=16000,
numavg=128):
"""Get a trace from the scope.
OUTPUT - (array voltage in volts, array time in seconds)
record_length can be 50, 100, 250, 500, 1000, 2000, 4000, 8000, 16000
FIXME: This currently takes as a parameter and sets the number of averages. It should instead
respect the number of averages set by self.average(). I think the scope can be made
to do this by fiddling with the ACQUIRE:STOPAFTER series of commands. -- ERJ
"""
## DATA ENCODINGS
## RIB - signed, MSB first
## RPB - unsigned, MSB first
## SRI - signed, LSB first
## SRP - unsigned, LSB first
wordLength = 4 #Hardcoding to set data transer word length to 4 bytes
recordLength = stop - start + 1
dev = self.selectedDevice(c)
yield dev.write('ACQUIRE:STATE OFF')
#DAT:SOU - set waveform source channel
yield dev.write('DAT:SOU CH%d' % channel)
#DAT:ENC - data format (binary/ascii)
yield dev.write('DAT:ENC ASCI')
yield dev.write('ACQUIRE:MODE AVERAGE')
yield dev.write('ACQUIRE:NUMAVG %d' % numavg)
yield dev.write('ACQUIRE:STOPAFTER COUNT %d' % numavg)
yield dev.write('ACQUIRE:STOPAFTER:MODE CONDITION')
#yield dev.write('ACQUIRE:STOPAFTER:CONDITION AVGComp')
yield dev.write('ACQUIRE:DATA:CLEAR')
#Starting and stopping point
yield dev.write('DAT:STAR %d' % start)
yield dev.write('DAT:STOP %d' % stop)
yield dev.write('HOR:MAI:REC %d' % record_length)
#Transfer waveform preamble
position = yield dev.query('HOR:MAI:POS?') # in units of divisions
yield dev.write('ACQUIRE:STATE ON')
while True:
busy = yield dev.query('BUSY?')
if '1' in busy:
sleep(2)
else:
break
#Transfer waveform data
stringData = yield dev.query('CURV?')
trace = numpy.array(stringData.split(','), dtype='float')
preamble = yield dev.query(
'WFMO?') # the preamble is always from the LAST curve sent
# so its important that CURV? comes BEFORE WFMO?
#Parse waveform preamble
voltsPerDiv, secPerDiv, voltUnits, timeUnits = _parsePreamble(preamble)
voltUnitScaler = Value(
1, voltUnits)['mV'] # converts the units out of the scope to mV
timeUnitScaler = Value(1, timeUnits)['ns']
#Convert from binary to volts
yUnit = yield dev.query('WFMO:YUNIT?')
yUnit = re.search(r'"(.*?)"', yUnit).groups()[0]
yUnit = Value(1.0, yUnit)
yScale = yield dev.query('WFMO:YSCALE?')
yScale = float(yScale)
#traceVolts = (trace * (1/(2.**25)) * VERT_DIVISIONS/2 * voltsPerDiv - float(position) * voltsPerDiv) * voltUnitScaler
traceVolts = trace * yUnit * yScale
time = numpy.linspace(0, HORZ_DIVISIONS * secPerDiv * timeUnitScaler,
len(traceVolts)) #recordLength)
returnValue((time, traceVolts))
def calibrateACPulse(cxn, boardname, baselineA, baselineB, use_switch=True):
"""Measures the impulse response of the DACs after the IQ mixer"""
pulseheight = 0x1800
reg = cxn.registry
reg.cd(['', keys.SESSIONNAME, boardname])
if use_switch:
switch = cxn.microwave_switch
uwaveSourceID = reg.get(keys.ANRITSUID)
uwaveSource = microwaveSourceServer(cxn, uwaveSourceID)
uwaveSourcePower = reg.get(keys.ANRITSUPOWER)
carrierFreq = reg.get(keys.PULSECARRIERFREQ)
sens = reg.get(keys.SCOPESENSITIVITY)
offs = reg.get(keys.SCOPEOFFSET, True, Value(0, 'mV'))
if use_switch:
switch.switch(boardname) #Hack to select the correct microwave switch
switch.switch(0)
uwaveSource.select_device(uwaveSourceID)
uwaveSource.frequency(carrierFreq)
uwaveSource.amplitude(uwaveSourcePower)
uwaveSource.output(True)
#Set up the scope
scope = cxn.sampling_scope
scopeID = reg.get(keys.SCOPEID)
scope.select_device(scopeID)
p = scope.packet().\
reset().\
channel(reg.get(keys.SSCOPECHANNEL, True, 2)).\
trace(1).\
record_length(5120L).\
average(128).\
sensitivity(sens).\
offset(offs).\
time_step(Value(2,'ns')).\
trigger_level(Value(0.18,'V')).\
trigger_positive()
p.send()
fpga = cxn[FPGA_SERVER_NAME]
fpga.select_device(boardname)
offsettime = reg.get(keys.TIMEOFFSET)
baseline = makeSample(baselineA, baselineB)
# print "Measuring offset voltage..."
# offset = (measureImpulseResponse(fpga, scope, baseline, baseline))[2:]
# offset = sum(offset) / len(offset)
print "Measuring pulse response DAC A..."
traceA = measureImpulseResponse(fpga,
scope,
baseline,
makeSample(baselineA + pulseheight,
baselineB),
dacoffsettime=offsettime['ns'])
print "Measuring pulse response DAC B..."
traceB = measureImpulseResponse(fpga,
scope,
baseline,
makeSample(baselineA,
baselineB + pulseheight),
dacoffsettime=offsettime['ns'])
starttime = traceA[0]
timestep = traceA[1]
if (starttime != traceB[0]) or (timestep != traceB[1]):
print """Time scales are different for measurement of DAC A and B.
Did you change settings on the scope during the measurement?"""
exit
#set output to zero
fpga.dac_run_sram([baseline] * 20)
uwaveSource.output(False)
ds = cxn.data_vault
ds.cd(['', keys.SESSIONNAME, boardname], True)
dataset = ds.new(keys.PULSENAME, [('Time', 'ns')], [('Voltage', 'A', 'V'),
('Voltage', 'B', 'V')])
setupType = reg.get(keys.IQWIRING)
ds.add_parameter(keys.IQWIRING, setupType)
ds.add_parameter(keys.PULSECARRIERFREQ, carrierFreq)
ds.add_parameter(keys.ANRITSUPOWER, uwaveSourcePower)
ds.add_parameter(keys.TIMEOFFSET, offsettime)
# begin unit strip party
starttime = starttime[starttime.unit] # stripping units
timestep = timestep[timestep.unit] # stripping units
traceA = traceA[traceA.unit] # stripping units
traceB = traceB[traceB.unit] # stripping units
data = np.transpose(\
[1e9*(starttime+timestep*np.arange(np.alen(traceA)-2)),
traceA[2:],traceB[2:]])
ds.add(data)
# traceA[2:]-offset,
# traceB[2:]-offset]))
if np.abs(np.argmax(np.abs(traceA-np.average(traceA))) - \
np.argmax(np.abs(traceB-np.average(traceB)))) \
* timestep > 0.5e-9:
print "Pulses from DAC A and B do not seem to be on top of each other!"
print "Sideband calibrations based on this pulse calibration will"
print "most likely mess up you sequences!"
print
print "Check the following pulse calibration file in the data vault:"
print datasetDir(dataset)
print "If the pulses are offset by more than 0.5 ns,"
print "bring up the board and try the pulse calibration again."
print 5
return (datasetNumber(dataset))
message = 987654321
timeout = 20
### END NODE INFO
"""
from labrad.server import setting, Signal
from labrad.devices import DeviceServer, DeviceWrapper
from twisted.internet.defer import inlineCallbacks, returnValue
from twisted.internet import reactor, defer
import labrad.units as units
from labrad.types import Value
import numpy as np
import time
#from exceptions import IndexError
TIMEOUT = Value(5, 's')
BAUD = 115200
def threeByteToIntAdc(DB1, DB2,
DB3): # This gives a 16 bit integer (between +/- 2^16)
return 65536 * DB1 + 256 * DB2 + DB3
def map2(x, in_min, in_max, out_min, out_max):
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
class AMI110Wrapper(DeviceWrapper):
@inlineCallbacks
def connect(self, server, port):
# names of server types (for classification of device type in registry)
global serverNameAD5764_DCBOX; serverNameAD5764_DCBOX = "ad5764_dcbox" # ad5764 dcbox
global serverNameAD5764_ACBOX; serverNameAD5764_ACBOX = "ad5764_acbox" # ad5764 acbox
global serverNameAD5780_DCBOX; serverNameAD5780_DCBOX = "ad5780_dcbox" # ad5780 dcbox quad
#Following servers are associated with the evaporator
global serverNameRVC300; serverNameRVC300 = "RVC_server" # RVC Pressure Controller (Pressure read out and leak valve)
global serverNameFTM2400; serverNameFTM2400 = "FTM_server" # Deposition Controller
global serverNameValveRelayController; serverNameValveRelayController = "valve_relay_server" # Valve and Relay Controller
global serverNameStepperController; serverNameStepperController = "stepper_server" # Stepper Motor Controller
global serverNamePowerSupply; serverNamePowerSupply = "power_supply_server" # TDK Power Supply
global IO_DELAY ;IO_DELAY = 0.1 # delay between read and write
global PORT_DELAY;PORT_DELAY = 2.0 # delay after opening serial port
global TIMEOUT; TIMEOUT = Value(1,'s') # timeout for reading
# ports that the manager will always ignore.
global blacklistedPorts
blacklistedPorts = ['COM1']
class serialDeviceManager(object):
def __init__(self):
self.serialConnect()
def serialConnect(self):
"""Initializes connection to LabRAD, the serial server, and the registry"""
self.cxn = labrad.connect() # connect to labrad
instancename = itead_motor_server
[startup]
cmdline = %PYTHON% %FILE%
timeout = 20
[shutdown]
message = 987654321
timeout = 20
### END NODE INFO
"""
from labrad.types import Value
from labrad.devices import DeviceServer, DeviceWrapper
from labrad.server import setting
from twisted.internet.defer import inlineCallbacks, returnValue
TIMEOUT = Value(5, 's') # serial read timeout
BAUDRATE = 115200
class StepperController(DeviceWrapper):
"""
arduino dual stepper devices
"""
@inlineCallbacks
def connect(self, server, port):
"""Here we make a connection to the serial server in LabRAD where all
the serial communication is handled"""
print 'connecting to "%s" on port "%s"...' % (server.name, port),
self.server = server
self.ctx = server.context(
) # grabs an identification number from the server
message = 987654321
timeout = 20
### END NODE INFO
"""
from labrad.server import setting, Signal
from labrad.devices import DeviceServer, DeviceWrapper
from twisted.internet.defer import inlineCallbacks, returnValue
from twisted.internet import reactor, defer
#import labrad.units as units
from labrad.types import Value
#import numpy as np
import time
from exceptions import IndexError
TIMEOUT = Value(1, 's')
BAUD = 115200
def twoByteToInt(DB1, DB2): # This gives a 16 bit integer (between +/- 2^16)
return 256 * DB1 + DB2
def map2(x, in_min, in_max, out_min, out_max):
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
class DAC_ADCWrapper(DeviceWrapper):
channels = [0, 1, 2, 3]
@inlineCallbacks