From 85dd905cfd75c23778475ae361e196c46b72f215 Mon Sep 17 00:00:00 2001 From: Oksana Shliakhtun Date: Wed, 17 May 2023 16:03:18 +0200 Subject: [PATCH] add SR lockin Change-Id: I4807ead7ceefcf0e266f7d215ef2898d54da9f53 --- frappy_psi/SR.py | 261 +++++++++++++++++++++++------------------------ 1 file changed, 127 insertions(+), 134 deletions(-) diff --git a/frappy_psi/SR.py b/frappy_psi/SR.py index ea516bc..c5f5906 100644 --- a/frappy_psi/SR.py +++ b/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=''))