def _pulserSetup(self, steps, forward=True, only=False):
p = self.pulser.packet()
p.enable(self.chMap.values(), only)
#advance channnel
p.select_channel(self.chMap['Adv'])
p.width(U.Value(10, 'us'))
p.delay(U.Value(10, 'us'))
p.polarity(True)
p.mode('Normal')
p.output(False)
#direction channel
p.select_channel(self.chMap['Dir'])
p.width(U.Value(1, 'ms'))
p.delay(U.Value(0, 's'))
p.polarity(forward)
p.mode('Normal')
p.output(False)
#trigger burst with step count
p.select_channel(0)
p.mode('Burst', steps)
yield p.send()
def _prepPulser(self):
p = self.pulser.packet()
#start channel settings
p.select_channel(self.chMap['Start'])
p.state(True)
p.width(U.Value(10, 'us'))
p.delay(U.Value(0, 's'))
p.polarity(True)
p.output(False)
p.mode('Single')
#mcs advance settings
p.select_channel(self.chMap['MCSAdv'])
p.state(True)
p.width(U.Value(10, 'us'))
p.delay(U.Value(0, 's'))
p.polarity(True)
p.output(False)
p.mode('DutyCycle', ratio2dutycycle(self.ratio))
#convert dwell time/MCS channel to dwell per advance
dwell = self.params['Dwell Time'] * ADV_PER_CH / self.params['MCS Ratio']
#configure global pulse settings
p.select_channel(0)
p.trigger_period(dwell)
p.mode('Burst', self._scanSteps())
yield p.send()
def _prepMCS(self):
p = self.mcs.packet()
p.sweeps(self.params['Passes'])
p.pass_length(self.params['Pass Length'])
p.acquisition_mode('RepSum')
p.discriminator_edge('Rising')
p.discriminator_level(U.Value(1.0, 'V'))
p.input_impedance(U.Value(50, 'Ohm'))
p.voltage_ramp([U.Value(0.0, 'V')])
p.dwell(U.Value(1.0, 'V'))
p.external_trigger(False)
yield p.send()
def move(pulser, advs, dwell=U.Value(50, 'ms'), moveChsOnly=False):
setMove(pulser, advs, dwell, moveChsOnly)
print 'Setting move with {0} {1}'.format(advs, dwell)
pulser.start()
print 'Pulser started'
while pulser.run_state():
sleep(dwell['s'] / 2)
def str2ramp(string):
elems = string.split(' ')
N = int(elems[0])
include = [1, 3] if N == 2 else [1, 2, 3]
fn = lambda x: U.Value(float(elems[x]), 'V')
ramp = tuple([fn(x) for x in include])
return ramp
def test_output_query_adjustable(self, dev):
dev.query.side_effect = ['ADJ', '2.0000']
resp = yield dev.output(1)
dev.query.assert_any_call(':PULSE1:OUTPUT:MODE?')
dev.query.assert_any_call(':PULSE1:OUTPUT:AMPL?')
assert resp == (True, U.Value(2.0, 'V'))
def test_move_now_sets_trigger_and_starts(self, srv, pls, mocker):
DWELL = U.Value(1, 's')
srv.dwell = DWELL
yield srv._moveSetup(10, True, True)
pls.packet().trigger_period.assert_called_with(DWELL)
pls.packet().start.assert_called_with()
def _pulserChannelInitialSetup(self):
p = self.pulser.packet()
#adv channel
p.select_channel(self.chs['Advance'])
p.width(U.Value(1, 'ms'))
p.delay(U.Value(0, 's'))
p.polarity(True)
p.output(False)
p.mode('Normal')
#direction channel
p.select_channel(self.chs['Direction'])
p.width(U.Value(1, 'ms'))
p.delay(U.Value(0, 's'))
p.mode('Normal')
p.output(False)
yield p.send()
def testArithmetic(self):
m = units.Unit('m')
kg = units.Unit('kg')
self.assertEquals(units.Value(5.0, None)*m, 5.0*m)
# addition
self.assertEquals(1.0*kg + 0.0, 1.0*kg)
self.assertNotEquals(1.0*kg, None)
def query(self, line):
yield self._portLock.acquire()
p = self.server.packet()
resp = yield p.read()\
.write_line(line)\
.pause(U.Value(40.0, 'ms'))\
.read_line()\
.send()
print 'RESPONSE: %s' % resp['read_line']
returnValue(resp['read_line'])
def _setupScan(self):
start = int(self.ui.startInput.text)
stop = int(self.ui.stopInput.text)
dwell = float(self.ui.dwellInput.text)
cPerBin = float(self.ui.binInput.text)
self.scanner.packet()\
.scan_range(start, stop)\
.dwell(U.Value(dwell, 's'))\
.channels_per_bin(cPerBin)\
.send()
def initializePulser(pulser, don, doff):
p = pulser.packet()
#TODO: Change to dynamic name
p.select_device(0)
p.select_channel(CH_MAP['MCS Start'])
p.state(False)
p.width(U.Value(10, 'us'))
p.delay(U.Value(0.0, 's'))
p.mode('Single')
p.polarity(True)
p.output(True, U.Value(2.0, 'V'))
p.select_channel(CH_MAP['MCS Advance'])
p.state(True)
p.width(U.Value(10, 'us'))
p.delay(U.Value(0, 'us'))
p.mode('DutyCycle', (don, doff))
p.polarity(True)
p.output(True, U.Value(2.0, 'V'))
p.select_channel(CH_MAP['Stepper Advance'])
p.state(True)
p.width(U.Value(10, 'us'))
p.delay(U.Value(10, 'us'))
p.mode('Normal')
p.polarity(True)
p.output(False)
p.select_channel(CH_MAP['Stepper Direction'])
p.state(True)
p.width(U.Value(1, 'ms'))
p.delay(U.Value(0.0, 's'))
p.mode('Normal')
p.polarity(True)
p.output(False)
p.send()
print 'Channels initialized'
print p
def test_external_dwell_threshold(srv, voltage, good):
value = U.Value(voltage, 'V')
if good:
string, respVal = srv.dwell(None, value)
assert respVal == value
assert srv.params['Dwell'] == (False, value)
assert string == 'External'
else:
with pytest.raises(Error):
srv.dwell(None, value)
def test_internal_dwell_time(srv, time, good):
value = U.Value(time, 's')
if good:
string, respVal = srv.dwell(None, value)
assert respVal == value
assert srv.params['Dwell'] == (True, value)
assert string == 'Internal'
else:
with pytest.raises(Error):
srv.dwell(None, value)
def all_ch_states(self):
chns = self.chMap.keys()
p = self.server.packet()
p.read() #clear buffer
for n in chns:
p.write(':PULSE%d:STATE?' % n)
p.pause(U.Value(30, 'ms'))
p.read(key=str(n))
resp = yield p.send()
parser = TYPE_MAP['bool'][1]
returnValue([(n, parser(resp[str(n)])) for n in chns])
def output(self, ch, isAdjustable=None, adjVoltage=None):
adjText = 'Adjustable' if isAdjustable else 'TTL'
adj = yield self._setParam(':OUTPUT:MODE', adjText, 'output', ch)
if adj is not None:
isAdj = adj == 'Adjustable'
if isAdj:
volts = yield self._setParam(':OUTPUT:AMPL', adjVoltage,
'voltage', ch)
else:
volts = U.Value(0.0, 'V')
returnValue((isAdj, volts))
def _initializeChannels(self):
p = self.pulser.packet()
#step advance channel
p.select_channel(self.chMap['Adv'])
p.state(True)
p.width(U.Value(10, 'us'))
p.delay(U.Value(10, 'us'))
p.mode('Normal')
p.polarity(True)
p.output(False)
#direction channel
p.select_channel(self.chMap['Dir'])
p.state(True)
p.width(U.Value(1, 'ms'))
p.delay(U.Value(0.0, 's'))
p.mode('Normal')
p.polarity(True)
p.output(False)
yield p.send()
def srv():
server = ScanServer()
server.pulser = mock.Mock()
server.stepper = mock.Mock()
#config settings
server.chMap = {'Start': 1, 'MCSAdv': 2}
server.ratio = 1.0
server.sRange = ((10, 0), (100, 0))
server.dwell = U.Value(1.0, 's')
server.passes = 2
server._running = False
return server
def query(self, line):
yield self._portLock.acquire()
p = self.server.packet()
ret = yield p.write_line(line)\
.pause(U.Value(20.0, 'ms'))\
.read()\
.send()
text = ret['read']
while not self._queryGood(text, line):
add = yield self.server.read()
text = text + add
self._portLock.release()
returnValue(text.split('\r\n')[-2])
def readParameters(self):
#duty cycle
ratio = float(self.ui.chPerBin.text())
chs = int(ratio * 8)
self.dcyc = (1, chs - 1)
#dwell time
dwell = float(self.ui.dwellTime.text())
self.dwell = U.Value(dwell, 's')
#pulse advances
self.advs = int(self.ui.channels.text()) * 8
#sweeps
self.sweeps = int(self.ui.passes.text())
def setMove(pulser, advs, period=U.Value(50, 'ms'), moveChsOnly=False):
p = pulser.packet()
#set move direction
p.select_channel(CH_MAP['Stepper Direction'])
p.polarity(advs > 0)
if moveChsOnly:
chns = [CH_MAP[c] for c in ['Stepper Advance', 'Stepper Direction']]
p.enable(chns, True)
#advances
p.select_channel(0)
p.mode('Burst', abs(advs))
p.trigger_period(period)
p.send()
def set_move(self, settings=None):
run = self.config if settings is None else settings
pulses = self.config2pulse(run)
p = self.pulser.packet()
#configure master trigger settings
p.select_channel(0)
p.mode('Burst', abs(run.channels))
p.trigger_period(U.Value(run.dwellTime, 's'))
#set individual pulse channels
for data in pulses.itervalues():
self.write_packet_data(p, data)
p.send()
def writeScanInfo(self):
startCh = int(self.ui.startChannelInput.text())
startFrac = int(self.ui.startFractionInput.text())
stopCh = int(self.ui.stopChannelInput.text())
stopFrac = int(self.ui.stopFractionInput.text())
dwell = float(self.ui.dwellTimeInput.text())
passes = int(self.ui.passInput.text())
ratio = float(self.ui.mcsBinInput.text())
p = self.scanner.packet()
p.scan_range(startCh, startFrac, stopCh, stopFrac)
p.dwell_time(U.Value(dwell, 's'))
p.passes(passes)
p.mcs_ratio(ratio)
p.send()
def setMove(pulser, advs, period=U.Value(50, 'ms'), moveChsOnly=False):
p = pulser.packet()
#set move direction
p.select_channel(CH_MAP['Stepper Direction'])
p.polarity(advs > 0)
if moveChsOnly:
moveChs = [CH_MAP[x] for x in MOVE_CHS]
p.enable(moveChs, True)
print 'Enabling only channels {0}'.format(moveChs)
#advances
p.select_channel(0)
p.mode('Burst', abs(advs) + 8)
p.trigger_period(period)
#now set stepper channel to move only advs number of channels
p.select_channel(CH_MAP['Stepper Advance'])
p.mode('Burst', abs(advs))
p.send()
def input_impedance(self, c, imped=None):
'''Set/query input signal impedance
None : Query current setting
True : Input at 50 Ohm impedance
False : Input at 1 kOhm impedance
Value can also be actual impedance value
Returns : Impedance value
'''
if imped is not None:
if type(imped) is bool:
val = imped
else:
if imped['Ohm'] not in [50, 1000]:
raise Error('Impedance must be 50, 1000 Ohms or boolean')
else:
val = imped['Ohm'] == 50
self.params['Impedance'] = val
return U.Value(50 if self.params['Impedance'] else 1000, 'Ohm')
def test_bad_dwell_time_raises(self, srv, dwell):
time = U.Value(dwell, 's')
with pytest.raises(Error):
yield srv.dwell_time(None, time)
def settings_setup(srv):
srv.dwell = U.Value(1, 's')
srv.ratio = 1.0
# pulser.trigger_period(U.Value(0.5, 's'))
# pulser.start()
def move(pulser, advs, dwell=U.Value(50, 'ms'), moveChsOnly=False):
setMove(pulser, advs, dwell)
print 'Move set with {0}, {1}, {2}'.format(pulser, advs, dwell)
pulser.start()
while pulser.run_state():
sleep(dwell['s'] / 2)
def scanPass(pulser, advs, dwell):
#start with all channels enabled
pulser.enable(CH_MAP.values())
#run pass
move(pulser, advs, dwell)
move(pulser, -(advs + 8), moveChsOnly=True)
move(pulser, 8, moveChsOnly=True)
if __name__ == '__main__':
cxn = labrad.connect()
pulser = cxn['BNC Serial Server']
pulser.select_device(0)
for i in range(2):
scanPass(pulser, 20, U.Value(0.25, 's'))
def move(pulser, advs, dwell=U.Value(50, 'ms'), moveChsOnly=False):
setMove(pulser, advs, dwell)
print 'Move set with {0}, {1}, {2}'.format(pulser, advs, dwell)
pulser.start()
while pulser.run_state():
sleep(dwell['s'] / 2)
def main():
# Loads config
with open("config.yml", 'r') as ymlfile:
cfg = yaml.load(ymlfile)
measurement = cfg['measurement']
measurement_settings = cfg[measurement]
max_values = cfg['max_values']
## DacAdc settings
dacadc_settings = cfg['dacadc_settings']
timeout = dacadc_settings['timeout']
dac1_ch = dacadc_settings['dac1_ch']
dac2_ch = dacadc_settings['dac2_ch']
adc1_ch = dacadc_settings['adc1_ch']
adc2_ch = dacadc_settings['adc2_ch']
delay_unit = dacadc_settings['delay_unit']
t_factor = time_factor(delay_unit)
# Meas parameters
meas_parameters = cfg['meas_parameters']
delay_meas = meas_parameters['delay']
# Ramp settings to first point
vgate2start_pnts = abs(
int(meas_parameters['vgate_rng'][0] / max_values['vgate_step_size']))
if vgate2start_pnts < 2: vgate2start_pnts = 3
vgate2start_delay = abs(
int(meas_parameters['vgate_rng'][0] /
(vgate2start_pnts * max_values['vgate_rate']) * 1e6))
if vgate2start_delay < 1: vgate2start_delay = 10
vset2start_pnts = abs(
int(meas_parameters['vset_rng'][0] / max_values['vset_step_size']))
if vset2start_pnts < 2: vset2start_pnts = 3
vset2start_delay = abs(
int(meas_parameters['vset_rng'][0] /
(vset2start_pnts * max_values['vset_rate']) * 1e6))
if vset2start_delay < 1: vset2start_delay = 10
# Ramp settings to next line
# Vgate ramps back whole range
vgate2next_pnts = abs(
int((meas_parameters['vgate_rng'][1] - meas_parameters['vgate_rng'][0])
/ max_values['vgate_step_size']))
if vgate2next_pnts < 2: vgate2next_pnts = 3
vgate2next_delay = abs(
int((meas_parameters['vgate_rng'][1] - meas_parameters['vgate_rng'][0])
/ (vgate2next_pnts * max_values['vgate_rate']) * 1e6))
if vgate2next_delay < 1: vset2next_delay = 10
# Vset ramps up to next line
vset2next_pnts = abs(
int((meas_parameters['vset_rng'][1] - meas_parameters['vset_rng'][0]) /
meas_parameters['vset_pnts'] / max_values['vset_step_size']))
if vset2next_pnts < 2: vset2next_pnts = 3
vset2next_delay = abs(
int((meas_parameters['vset_rng'][1] - meas_parameters['vset_rng'][0]) /
meas_parameters['vset_pnts'] /
(vset2next_pnts * max_values['vset_rate']) * 1e6))
if vset2next_delay < 1: vset2next_delay = 10
# Ramp settings to zero
vgate2zero_pnts = abs(
int(meas_parameters['vgate_rng'][1] / max_values['vgate_step_size']))
if vgate2zero_pnts < 2: vgate2zero_pnts = 3
vgate2zero_delay = abs(
int(meas_parameters['vgate_rng'][1] /
(vgate2zero_pnts * max_values['vgate_rate']) * 1e6))
if vgate2zero_delay < 1: vgate2zero_delay = 10
vset2zero_pnts = abs(
int(meas_parameters['vset_rng'][1] / max_values['vset_step_size']))
if vset2zero_pnts < 2: vset2zero_pnts = 3
vset2zero_delay = abs(
int(meas_parameters['vset_rng'][1] /
(vset2zero_pnts * max_values['vset_rate']) * 1e6))
if vset2zero_delay < 1: vset2zero_delay = 10
# Safety check
safety_check(meas_parameters, cfg['max_values'], t_factor)
# Lockin settings
lockin_settings = cfg['lockin_settings']
tc_var = lockin_settings['tc']
sens_var = lockin_settings['sensitivity']
if delay_meas * t_factor <= 3 * tc_var:
print("Warning: delay is less than 3x lockin time constant.")
# Labrad connections and Instrument Configurations
cxn = labrad.connect()
reg = cxn.registry
dv = cxn.data_vault
dac_adc = cxn.dac_adc
dac_adc.select_device()
dac_adc.initialize()
dac_adc.delay_unit(delay_unit)
dac_adc.timeout(U.Value(timeout, 's'))
dac_adc.read()
dac_adc.read()
# Create datavault data set
create_file(dv, cfg)
# Mesh parameters
pxsize = (meas_parameters['vgate_pnts'], meas_parameters['vset_pnts'])
extent = (meas_parameters['vgate_rng'][0], meas_parameters['vgate_rng'][1],
meas_parameters['vset_rng'][0], meas_parameters['vset_rng'][1])
num_x = pxsize[0]
num_y = pxsize[1]
print(extent, pxsize)
# Start timer
time.sleep(3)
t0 = time.time()
# Estimated time
est_time = (num_x * num_y * delay_meas * t_factor +
vgate2next_pnts * vgate2next_delay * 1e-6 * num_y) / 60.0
dt = num_x * delay_meas * t_factor / 60.0
print(
"Will take a total of {} mins. With each line trace taking {} This deprecated for SET."
.format(est_time, dt))
m = mesh(offset=(0.0, -0.0),
xrange=(extent[0], extent[1]),
yrange=(extent[2], extent[3]),
pxsize=pxsize)
mdn = m # for future implementation
for i in range(num_y):
data_x = np.zeros(num_x)
data_y = np.zeros(num_x)
vec_x = m[i, :][:, 0]
vec_y = m[i, :][:, 1]
# vec_x = (m[i, :][:, 0] - dacadc_settings['ch1_offset'])
# vec_y = (m[i, :][:, 1] - dacadc_settings['ch2_offset'])
# md and mn for future implementation
md = mdn[i, :][:, 0]
mn = mdn[i, :][:, 1]
mask = np.logical_and(np.logical_and(vec_x <= X_MAX, vec_x >= X_MIN),
np.logical_and(vec_y <= Y_MAX, vec_y >= Y_MIN))
if np.any(mask == True):
start, stop = np.where(mask == True)[0][0], np.where(
mask == True)[0][-1]
start = start.item()
stop = stop.item()
num_points = stop - start + 1
# Ramping to initial values
if i == 0:
dac_adc.delay_unit(0)
d_read = dac_adc.ramp1(dac1_ch, 0, vec_x[start], vgate2start_pnts,
vgate2start_delay)
time.sleep(2)
else:
dac_adc.delay_unit(0)
previous_vec_x = m[i - 1, :][:, 0]
d_read = dac_adc.ramp1(dac1_ch, previous_vec_x[stop], vec_x[start],
vgate2next_pnts, vgate2next_delay)
if i == 0:
dac_adc.delay_unit(0)
d_read = dac_adc.ramp1(dac2_ch, 0, vec_y[start], vset2start_pnts,
vset2start_delay)
time.sleep(2)
else:
dac_adc.delay_unit(0)
previous_vec_y = m[i - 1, :][:, 1]
d_read = dac_adc.ramp1(dac2_ch, previous_vec_y[stop], vec_y[start],
vset2next_pnts, vset2next_delay)
dac_adc.delay_unit(delay_unit)
print("{} of {} --> Ramping. Points: {}".format(
i + 1, num_y, num_points))
d_read = dac_adc.buffer_ramp([dac1_ch, dac2_ch], [adc1_ch, adc2_ch],
[vec_x[start], vec_y[start]],
[vec_x[stop], vec_y[stop]], num_points,
delay_meas, ADC_AVGSIZE)
d_tmp = d_read
data_x[start:stop + 1], data_y[start:stop + 1] = d_tmp
#radius = np.sqrt(np.square(data_x) + np.square(data_y)) * sens_var
radius = np.array(data_x)
phase = np.array(data_y) * sens_var
#phase = np.arctan2(data_y, data_x)
# TODO rescale lock in sensitivity
j = np.linspace(0, num_x - 1, num_x)
ii = np.ones(num_x) * i
t1 = np.ones(num_x) * time.time() - t0
totdata = np.array(
[j, ii, vec_x, vec_y, radius, phase, md, mn, data_x, data_y, t1])
dv.add(totdata.T)
# Ramp down to zero if last point
if (i == num_y - 1):
dac_adc.ramp1(dac1_ch, vec_x[stop], 0, 10000, 300)
dac_adc.ramp1(dac2_ch, vec_x[stop], 0, 1000, 500)
print("it took {} s. to write data".format(time.time() - t0))
