From 36c512d50b15c14ad08fb1fe6ac19887fbce73de Mon Sep 17 00:00:00 2001 From: Markus Zolliker Date: Mon, 29 Jan 2024 10:23:58 +0100 Subject: [PATCH] frappy_psi/SR.py: got changes from develop branch + move soft auto range from read_value to doPoll Change-Id: I0bf8ac15f8515e55cd9131be33615908ffc99c12 --- frappy_psi/SR.py | 313 ++++++++++++++++++++++++++++++----------------- 1 file changed, 203 insertions(+), 110 deletions(-) diff --git a/frappy_psi/SR.py b/frappy_psi/SR.py index bd36ed7..2de98b5 100644 --- a/frappy_psi/SR.py +++ b/frappy_psi/SR.py @@ -16,18 +16,20 @@ # 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # Module authors: -# Daniel Margineda , Oksana Shliakhtun +# Daniel Margineda +# Oksana Shliakhtun # ***************************************************************************** """Signal Recovery SR7270: lockin amplifier for AC susceptibility""" +import re from frappy.core import Readable, Parameter, FloatRange, TupleOf, \ - HasIO, StringIO, IntRange, BoolType, Writable, EnumType + HasIO, StringIO, BoolType, EnumType from frappy.errors import RangeError class SR_IO(StringIO): end_of_line = b'\x00' - identification = [('ID', r'.*')] # Identification; causes the lock-in amplifier to respond with the number 7270 + identification = [('ID', r'72.*')] # Identification; causes the lock-in amplifier to respond with the model number def communicate(self, cmd): # remove dash from terminator reply = super().communicate(cmd) @@ -37,142 +39,135 @@ class SR_IO(StringIO): class XY(HasIO, 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('is noise control mode on', BoolType(), readonly=False) - phase = Parameter('reference phase control', FloatRange(-360, 360), unit='deg', readonly=False) - frequency = Parameter('oscill. frequen. control', FloatRange(0.001, 250e3), unit='Hz', readonly=False, - group='frequency') - amplitude = Parameter('oscill. amplit. control', FloatRange(0.00, 5), unit='V_rms', readonly=False) - #filter = Parameter('line frequency filter', unit='Hz') + freq = Parameter('oscill. frequen. control', FloatRange(0, 250e3), unit='Hz', readonly=False) + amp = Parameter('oscill. amplit. control', FloatRange(0.00, 5), unit='V_rms', readonly=False) + range = Parameter('sensitivity value', FloatRange(0.00, 1), unit='V', default=1, readonly=False) + autorange = Parameter('autorange_on', EnumType('autorange', off=0, soft=1, hard=2), + readonly=False, default=0) - sen_range = {name: value + 1 for value, name in enumerate( + sen_range = {index + 1: name for index, 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) + irange = Parameter('sensitivity index', EnumType('sensitivity index range', sen_range)) + nm = Parameter('noise mode on', BoolType(), readonly=False) + phase = Parameter('reference phase control', FloatRange(-360, 360), unit='deg', readonly=False) + vmode = Parameter('control mode', EnumType(both_grounded=0, A=1, B=2, A_B_diff=3), readonly=False) - time_const = {name: value for value, name in enumerate( - ['10us', '20us', '50us', '100us', '200us', '500us', '1ms', '2ms', '5ms', '10ms', - '20ms', '50ms', '100ms', '200ms', '500ms', '1s', '2s', '5s', '10s', '20s', '50s', - '100s', '200s', '500s', '1ks', '10ks', '20ks', '50ks', '100ks'] - )} - - tc = Parameter('time const. value', FloatRange(0.00005, 100000), unit='s', readonly=False) - itc = Parameter('time const. index', EnumType('time const. index range', time_const), readonly=False) ioClass = SR_IO - def comparison(self, curr_value, new_value, value_dict): - c_ind = None # closest index - c_diff = None # closets difference - - for index, value in value_dict.items(): - if c_diff is None or diff < c_diff: - c_ind = index - c_diff = c_diff - - if abs(curr_value - new_value) < c_diff: - return c_ind - else: - for index, value in value_dict.items(): - diff = abs(new_value - value) - if c_diff is None or diff < c_diff: - c_ind = index - c_diff = diff - return c_ind + def doPoll(self): + super().doPoll() + if self.autorange == 1: # soft auto range + 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) def comm(self, cmd): - reply, status, overload = self.communicate(cmd).split(';') + reply, status, overload = self.communicate(cmd).split(';') # try/except + reply = reply.rstrip('\n') if overload != '0': self.status = (self.Status.WARN, f'overload {overload}') self.status = (self.Status.IDLE, '') return reply - def read_vmode(self): - return self.comm('VMODE') - - 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') - - def write_autosen_on(self, autosen_on): - return self.comm(f'AUTOMATIC {autosen_on}') - - def read_irange(self): - return self.comm('SEN') - - def write_irange(self, irange): - self.comm(f'IMODE {0}') - self.comm(f'SEN {irange}') - self.read_range() - return irange - - def read_range(self): - return self.comm('SEN.') # range value - - def write_range(self): - self.comm(f'IMODE 0') - curr_value = self.read_range() - new_value = self.value - c_ind = self.comparison(curr_value, new_value, self.sen_range) - return self.comm(f'SEN {c_ind}') - - 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 write_tc(self): - pass - - def read_itc(self): - return self.comm('TC') - - def write_itc(self, new_itc): - curr_value = self.read_itc() - new_value = self.time_const[self.itc] - c_ind = self.comparison(curr_value, new_value, self.time_const) - - if abs(curr_value - new_value) < c_diff: - if self.read_noise_control() == 1 and (5e-4 <= self.time_const[new_itc] <= 1e-2): - raise RangeError('not allowed with noisemode=1') - return self.comm(f'TC {new_itc}') + def string_to_value(self, value): + """ + This method is used for writing methods (sensitivity range and time constant in particular). As the dictionaries + with names were used (pop-up list in gui) this method transforms names into float values, that can be used + further. + :param value: + :return: + """ + value_with_unit = re.compile(r'(\d+)([pnumkMG]?)') + value, pfx = value_with_unit.match(value).groups() + pfx_dict = {'p': 1e-12, 'n': 1e-9, 'u': 1e-6, 'm': 1e-3, 'k': 1e3, 'M': 1e6, 'G': 1e9} + if pfx in pfx_dict: + value = round(float(value) * pfx_dict[pfx], 12) + return float(value) def read_value(self): - reply = self.comm('XY.').split(b',') + reply = self.comm('XY.').split(',') x = float(reply[0]) y = float(reply[1]) return x, y - def write_value(self, value): - return self.comm(f'XY {value}') + def read_freq(self): + return float(self.comm('OF.')) - def read_frequency(self): - return self.comm('OF.') + def write_freq(self, freq): + self.comm(f'OF. {freq}') + return freq - def write_frequency(self, frequency): - frequency = self.frequency - return self.comm(f'OF. {frequency}') + def read_autorange(self): + reply = self.comm('AUTOMATIC') + # determine hardware autorange + if reply == 1: # soft + return 2 # hard + if self.autorange == 0: # soft + return self.autorange # read autorange + return self.autorange # off - def read_amplitude(self): - return self.comm('OA.') + 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_amplitude(self, amplitude): - return self.comm(f'OA. {amplitude}') + def read_amp(self): + return float(self.comm('OA.')) + + def write_amp(self, amp): + self.comm(f'OA. {amp}') + return amp + + def read_irange(self): + reply = self.comm('SEN') + return int(reply) + + def write_irange(self, irange): + value = int(irange) + self.comm(f'SEN {value}') + self.read_range() + return value + + def read_range(self): + reply = self.comm('SEN.') # range value + return float(reply) + + def write_range(self, target): + cl_idx = None + + for idx, name in self.sen_range.items(): + + if idx < len(self.sen_range): + value_l = self.string_to_value(self.sen_range.get(idx)) + value_r = self.string_to_value(self.sen_range.get(idx + 1)) + if value_l < target <= value_r: + cl_idx = idx + 1 + break + cl_idx = idx + self.write_irange(cl_idx) + return self.read_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 # phase and autophase def read_phase(self): - return self.comm('REFP.') + reply = self.comm('REFP.') + return float(reply) def write_phase(self, value): self.comm(f'REFP {round(1000 * value)}') @@ -182,3 +177,101 @@ class XY(HasIO, Readable): """auto phase""" self.read_phase() return self.comm('AQN') + + def read_vmode(self): + reply = self.comm('VMODE') + return int(reply) + + def write_vmode(self, vmode): + value = int(vmode) + self.comm(f'VMODE {value}') + return value + + +class XY70(XY): + + time_const = {name: value for value, name in enumerate( + ['10us', '20us', '50us', '100us', '200us', '500us', '1ms', '2ms', '5ms', '10ms', + '20ms', '50ms', '100ms', '200ms', '500ms', '1s', '2s', '5s', '10s', '20s', '50s', + '100s', '200s', '500s', '1ks', '2ks', '5ks', '10ks', '20ks', '50ks', '100ks'] + )} + + tc = Parameter('time const. value', FloatRange(0.00001, 100000), unit='s', readonly=False) + itc = Parameter('time const. index', EnumType('time const. index range', time_const), readonly=False) + + ioClass = SR_IO + + def comm(self, cmd): + reply, status, overload = self.communicate(cmd).split(';') + reply = reply.rstrip('\n') + if overload != '0': + self.status = (self.Status.WARN, f'overload {overload}') + self.status = (self.Status.IDLE, '') + return reply + + def read_tc(self): + reply = self.comm('TC.') + return float(reply) + + def write_tc(self, target): + cl_idx = None + cl_diff = float('inf') + + for name, idx in self.time_const.items(): + value = self.string_to_value(name) + diff = abs(value - target) # range is the actual value, like SEN. + if diff < cl_diff: + cl_idx = idx + cl_diff = diff + + if self.nm is False or (self.nm is True and 5 <= cl_idx <= 9): + self.comm(f'TC {cl_idx}') + return self.read_tc() + raise RangeError('Not allowed with noisemode=1') + + def read_itc(self): + return int(self.comm('TC')) + + def write_itc(self, itc): + value = int(itc) + self.comm(f'TC {value}') + self.read_tc() + return value + + +class XY65(XY): + + time_const = {name: value for value, name in enumerate( + ['10us', '20us', '40us', '80us', '160us', '320us', '640us', '5ms', '10ms', '20ms', + '50ms', '100ms', '200ms', '500ms', '1s', '2s', '5s', '10s', '20s', '50s', '100s', + '200s', '500s', '1ks', '2ks', '5ks', '10ks', '20ks', '50ks', '100ks'] + )} + + def read_tc(self): + reply = self.comm('TC.') + return float(reply) + + def write_tc(self, target): + cl_idx = None + cl_diff = float('inf') + + for name, idx in self.time_const.items(): + value = self.string_to_value(name) + diff = abs(value - target) # range is the actual value, like SEN. + if diff < cl_diff: + cl_idx = idx + cl_diff = diff + + if self.nm is False or (self.nm is True and 5 <= cl_idx <= 9): + self.comm(f'TC {cl_idx}') + return self.read_tc() + raise RangeError('Not allowed with noisemode=1') + + def read_itc(self): + return int(self.comm('TC')) + + def write_itc(self, itc): + value = int(itc) + self.comm(f'TC {value}') + self.read_tc() + return value