add SR lockin
Change-Id: I4807ead7ceefcf0e266f7d215ef2898d54da9f53
This commit is contained in:
Oksana Shliakhtun
parent
04b9bed7c9
commit
85dd905cfd
261
frappy_psi/SR.py
261
frappy_psi/SR.py
@ -21,115 +21,157 @@
|
||||
"""Signal Recovery SR7270: lockin amplifier for AC susceptibility"""
|
||||
|
||||
from frappy.core import Readable, Parameter, FloatRange, TupleOf, \
|
||||
HasIO, StringIO, Attached, IntRange, BoolType, Writable, EnumType
|
||||
HasIO, StringIO, IntRange, BoolType, Writable, EnumType
|
||||
|
||||
|
||||
class SR7270_IO(StringIO):
|
||||
class SR_IO(StringIO):
|
||||
end_of_line = b'\x00'
|
||||
identification = [('ID', r'.*')] # Identification
|
||||
identification = [('ID', r'.*')] # Identification; causes the lock-in amplifier to respond with the number 7270
|
||||
|
||||
|
||||
class Ametek(StringIO):
|
||||
def get_par(self, cmd): # remove dash from terminator
|
||||
reply = StringIO.communicate(self, cmd)
|
||||
def communicate(self, cmd): # remove dash from terminator
|
||||
reply = super().communicate(cmd)
|
||||
status = self._conn.readbytes(2, 0.1) # get the 2 status bytes
|
||||
return reply + ';%d;%d' % tuple(status)
|
||||
|
||||
|
||||
class Ametek(StringIO, HasIO):
|
||||
ioClass = SR_IO
|
||||
|
||||
def comm(self, cmd):
|
||||
reply, status, overload = self.get_par(cmd).split(';')
|
||||
if overload != '0':
|
||||
self.status = self.Status.WARN, f'overload {overload}'
|
||||
self.status = self.Status.IDLE, ''
|
||||
reply, status, overload = self.communicate(cmd).split(b';')
|
||||
if overload != b'0':
|
||||
self.status = (self.Status.WARN, f'overload {overload}')
|
||||
self.status = (self.Status.IDLE, '')
|
||||
return reply
|
||||
|
||||
|
||||
class XY(HasIO, Readable):
|
||||
ioClass = SR7270
|
||||
|
||||
# parameters required an initial value but initwrite write the default value for polled parameters
|
||||
class XY(Ametek, Readable):
|
||||
value = Parameter('X, Y', datatype=TupleOf(FloatRange(unit='V'), FloatRange(unit='V')))
|
||||
vmode = Parameter('control mode', EnumType(both_grounded=0, A=1, B=2, A_B_diff=3), readonly=False)
|
||||
range = Parameter('sensitivity value', FloatRange(0.00, 1), unit='V', default=1)
|
||||
autosen_on = Parameter('is auto sensitivity on', BoolType(), readonly=False)
|
||||
noise_control = Parameter('noise control mode', BoolType(), readonly=False)
|
||||
phase = Parameter('reference phase control', FloatRange(-360, 360), unit='deg', readonly=False)
|
||||
|
||||
sen_range = {name: value + 1 for value, name in enumerate(
|
||||
['2nV', '5nV', '10nV', '20nV', '50nV', '100nV', '200nV', '500nV', '1uV',
|
||||
'2uV', '5uV', '10uV', '20uV', '50uV', '100uV', '200uV', '500uV', '1mV',
|
||||
'2mV', '5mV', '10mV', '20mV', '50mV', '100mV', '200mV', '500mV', '1V']
|
||||
)}
|
||||
irange = Parameter('sensitivity index', EnumType('sensitivity index range', sen_range), readonly=False)
|
||||
|
||||
# separate module (Writable)
|
||||
class Frequency(Ametek, Writable):
|
||||
value = Parameter('exc_freq_int', FloatRange(0.001, 250e3, unit='Hz'),
|
||||
readonly=False, default=1000) # initwrite=True,
|
||||
time_const = {value: name for value, name in enumerate(
|
||||
[('10us', 'N/A'), ('20us', 'N/A'), ('50us', 'N/A'), ('100us', 'N/A'),
|
||||
('200us', 'N/A'), ('500us', '500us'), ('1ms', '1ms'), ('2ms', '2ms'),
|
||||
('5ms', '5ms'), ('10ms', '10ms'), ('20ms', 'N/A'), ('50ms', 'N/A'),
|
||||
('100ms', 'N/A'), ('200ms', 'N/A'), ('500ms', 'N/A'), ('1s', 'N/A'),
|
||||
('2s', 'N/A'), ('5s', 'N/A'), ('10s', 'N/A'), ('20s', 'N/A'), ('50s', 'N/A'),
|
||||
('100s', 'N/A'), ('200s', 'N/A'), ('500s', 'N/A'), ('1ks', 'N/A'),
|
||||
('10ks', 'N/A'), ('20ks', 'N/A'), ('50ks', 'N/A'), ('100ks', 'N/A')]
|
||||
)}
|
||||
itc = Parameter('time const. index', EnumType('time const. index range', time_const), readonly=False)
|
||||
|
||||
def read_freq(self):
|
||||
return self.comm('OF.')
|
||||
def read_vmode(self):
|
||||
return self.comm('VMODE')
|
||||
|
||||
def write_freq(self, value):
|
||||
self.comm(f'OF. {value}')
|
||||
return value
|
||||
def write_vmode(self, vmode):
|
||||
self.comm(f'IMODE {0}')
|
||||
return self.comm(f'VMODE {vmode}')
|
||||
|
||||
def read_autosen_on(self):
|
||||
return self.comm('AUTOMATIC')
|
||||
|
||||
# separate module (Writable)
|
||||
class Amp(Ametek, Writable):
|
||||
value = Parameter('exc_volt_int',
|
||||
FloatRange(0.00, 5, unit='Vrms'),
|
||||
readonly=False, default=0.1) # initwrite=True,
|
||||
# unify the following
|
||||
range = Parameter('sensitivity value', FloatRange(0.00, 1, unit='V'), default=1)
|
||||
irange = Parameter('sensitivity index', IntRange(0, 27), readonly=False, default=25)
|
||||
def write_autosen_on(self, autosen_on):
|
||||
return self.comm(f'AUTOMATIC {autosen_on}')
|
||||
|
||||
autorange = Parameter('autorange_on', EnumType('autorange', off=0, soft=1, hard=2), readonly=False,
|
||||
default=0) # , initwrite=True
|
||||
def read_irange(self):
|
||||
return self.comm('SEN')
|
||||
|
||||
# unify the following
|
||||
tc = Parameter('time constant value', FloatRange(10e-6, 100), unit='s', default=0.1)
|
||||
itc = Parameter('time constant index', IntRange(0, 30), default=14, readonly=False)
|
||||
def write_irange(self, irange):
|
||||
self.comm(f'IMODE {0}')
|
||||
self.comm(f'SEN {irange}')
|
||||
self.read_range()
|
||||
return irange
|
||||
|
||||
nm = Parameter('noise mode', BoolType(), readonly=False, default=0)
|
||||
phase = Parameter('Reference phase control', FloatRange(-360, 360, unit='deg'),
|
||||
readonly=False, default=0)
|
||||
def read_range(self):
|
||||
return self.comm('SEN.') # range value
|
||||
|
||||
# convert to enum
|
||||
vmode = Parameter('control mode', IntRange(0, 3), readonly=False, default=3)
|
||||
def write_range(self):
|
||||
self.comm(f'IMODE {0}')
|
||||
curr_value = self.read_range()
|
||||
new_value = self.value
|
||||
c_ind = None # closest parameters
|
||||
c_diff = None
|
||||
for index, value in self.sen_range.items():
|
||||
diff = abs(curr_value - value)
|
||||
if c_diff is None or diff < c_diff:
|
||||
c_ind = index
|
||||
c_diff = diff
|
||||
if abs(curr_value - new_value) < c_diff:
|
||||
return self.comm(f'SEN {c_ind}')
|
||||
else:
|
||||
for index, value in self.sen_range.items():
|
||||
diff = abs(new_value - value)
|
||||
if c_diff is None or diff < c_diff:
|
||||
c_ind = index
|
||||
c_diff = diff
|
||||
return self.comm(f'SEN {c_ind}')
|
||||
|
||||
# dac = Parameter('output DAC channel value', datatype=TupleOf(IntRange(1, 4), FloatRange(0.0, 5000, unit='mV')),
|
||||
# readonly=False, initwrite=True, default=(3,0))
|
||||
# dac = Parameter('output DAC channel value', FloatRange(-10000, 10000, unit='mV'),
|
||||
# readonly=False, initwrite=True, default=0)
|
||||
def read_noise_control(self):
|
||||
return self.comm('NOISEMODE')
|
||||
|
||||
def write_noise_control(self, noise_control):
|
||||
return self.comm(f'NOISEMODE {noise_control}')
|
||||
|
||||
def read_tc(self):
|
||||
return self.comm('TC.')
|
||||
|
||||
def read_itc(self):
|
||||
return self.comm(f'TC')
|
||||
|
||||
# def write_tc(self, itc):
|
||||
# if self.noise_control == 0:
|
||||
# self.itc = self.
|
||||
|
||||
# OS - there should be parameter+command IMODE before
|
||||
def read_value(self):
|
||||
reply = self.comm('XY.').split(',')
|
||||
x = float(reply[0])
|
||||
y = float(reply[1])
|
||||
if self.autorange == 1: # soft
|
||||
if max(abs(x), abs(y)) >= 0.9 * self.range and self.irange < 27:
|
||||
self.write_irange(self.irange + 1)
|
||||
elif max(abs(x), abs(y)) <= 0.3 * self.range and self.irange > 1:
|
||||
self.write_irange(self.irange - 1)
|
||||
self._x.value = x # to update X,Y classes which will be the collected data.
|
||||
self._y.value = y
|
||||
return x, y
|
||||
|
||||
def write_autorange(self, value):
|
||||
if value == 2: # hard
|
||||
self.comm('AS') # put hardware autorange on
|
||||
self.comm('AUTOMATIC. 1')
|
||||
else:
|
||||
self.comm('AUTOMATIC. 0')
|
||||
return value
|
||||
def write_value(self, value):
|
||||
return self.comm(f'XY {value}')
|
||||
|
||||
def read_autorange(self):
|
||||
reply = self.comm('AUTOMATIC')
|
||||
# determine hardware autorange
|
||||
if reply == 1: # "hardware auto range is on"
|
||||
return 2 # hard
|
||||
if self.autorange == 0: # soft
|
||||
return self.autorange() # read autorange
|
||||
return reply # off
|
||||
|
||||
class Frequency(XY, Writable):
|
||||
value = Parameter('oscill. frequen. control', FloatRange(0.001, 250e3), unit='Hz', readonly=False)
|
||||
target = Parameter('target frequency', FloatRange(0.001, 250e3), unit='Hz', readonly=False)
|
||||
|
||||
def read_value(self):
|
||||
return self.comm('OF.')
|
||||
|
||||
def write_target(self,):
|
||||
target = self.target()
|
||||
return self.comm(f'OF. {target}')
|
||||
|
||||
|
||||
class Amplitude(XY, Writable):
|
||||
value = Parameter('oscill. amplit. control', FloatRange(0.00, 5), unit='V_rms', readonly=False)
|
||||
target = Parameter('target amplit.', FloatRange(0.00, 5), unit='V_rms', readonly=False)
|
||||
|
||||
# unify the following
|
||||
# dac = Parameter('output DAC channel value', datatype=TupleOf(IntRange(1, 4), FloatRange(0.0, 5000, unit='mV')),
|
||||
# readonly=False, initwrite=True, default=(3,0))
|
||||
# dac = Parameter('output DAC channel value', FloatRange(-10000, 10000, unit='mV'),
|
||||
# readonly=False, initwrite=True, default=0)
|
||||
# oscillator amplitude module
|
||||
def read_amp(self):
|
||||
reply = self.comm('OA.')
|
||||
return reply
|
||||
|
||||
def write_amp(self, value):
|
||||
self.comm(f'OA. {value}')
|
||||
return value
|
||||
def read_value(self):
|
||||
return self.comm('OA.')
|
||||
|
||||
def write_target(self):
|
||||
target = self.target()
|
||||
return self.comm(f'OA. {target}')
|
||||
|
||||
# external output DAC
|
||||
# def read_dac(self):
|
||||
@ -142,75 +184,26 @@ class Amp(Ametek, Writable):
|
||||
# self.comm('DAC 3 %g' % value)
|
||||
# return value
|
||||
|
||||
# sensitivity module
|
||||
def read_range(self):
|
||||
reply = self.comm('SEN.')
|
||||
return reply
|
||||
|
||||
def write_irange(self, value):
|
||||
self.comm('SEN %g' % value)
|
||||
self.read_range()
|
||||
return value
|
||||
|
||||
def read_irange(self):
|
||||
reply = self.comm('SEN')
|
||||
return reply
|
||||
|
||||
# time constant module/ noisemode off or 0 allows to use all the time constant range
|
||||
def read_nm(self):
|
||||
reply = self.comm('NOISEMODE')
|
||||
return reply
|
||||
|
||||
def write_nm(self, value):
|
||||
self.comm('NOISEMODE %d' % int(value))
|
||||
self.read_nm()
|
||||
return value
|
||||
|
||||
def read_tc(self):
|
||||
reply = self.comm('TC.')
|
||||
return reply
|
||||
|
||||
def write_itc(self, value):
|
||||
self.comm('TC %g' % value)
|
||||
self.read_tc()
|
||||
return value
|
||||
|
||||
def read_itc(self):
|
||||
reply = self.comm('TC')
|
||||
return reply
|
||||
|
||||
# phase and autophase
|
||||
def read_phase(self):
|
||||
reply = self.comm('REFP.')
|
||||
return reply
|
||||
|
||||
def write_phase(self, value):
|
||||
self.comm('REFP %d' % round(1000 * value, 0))
|
||||
self.comm(f'REFP {round(1000 * value)}')
|
||||
self.read_phase()
|
||||
return value
|
||||
|
||||
def aphase(self):
|
||||
"""auto phase"""
|
||||
self.read_phase()
|
||||
reply = self.comm('AQN')
|
||||
self.read_phase()
|
||||
return self.comm('AQN')
|
||||
|
||||
# voltage input configuration 0:grounded,1=A,2=B,3=A-B
|
||||
# def read_vmode(self):
|
||||
# reply = self.comm('VMODE')
|
||||
# return reply
|
||||
|
||||
def write_vmode(self, value):
|
||||
self.comm(f'IMODE {0}') # voltage enabled
|
||||
self.comm(f'VMODE {value}')
|
||||
return value
|
||||
|
||||
|
||||
class Comp(Readable):
|
||||
enablePoll = False
|
||||
value = Parameter(datatype=FloatRange(unit='V'))
|
||||
|
||||
|
||||
class arg(Readable):
|
||||
enablePoll = False
|
||||
value = Parameter(datatype=FloatRange(unit=''))
|
||||
# class Comp(Ametek, Readable):
|
||||
# enablePoll = False
|
||||
# value = Parameter(datatype=FloatRange(unit='V'))
|
||||
#
|
||||
#
|
||||
# class arg(Ametek, Readable):
|
||||
# enablePoll = False
|
||||
# value = Parameter(datatype=FloatRange(unit=''))
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user