From f8a19c461991ca3d0a8008ef072ed25fd8b81ff1 Mon Sep 17 00:00:00 2001 From: redred Date: Mon, 21 Oct 2019 16:36:27 +0200 Subject: [PATCH 1/6] First actual version, semisolved recv before write&read issue --- RotScan.py | 130 +++++ RotScanTest.py | 10 +- instruments/lockinamplifier.py | 988 +++++++++++++++++++++++++++++++++ 3 files changed, 1124 insertions(+), 4 deletions(-) create mode 100644 RotScan.py diff --git a/RotScan.py b/RotScan.py new file mode 100644 index 0000000..e6d7ede --- /dev/null +++ b/RotScan.py @@ -0,0 +1,130 @@ +# -*- coding: utf-8 -*- +""" +Created on Mon Aug 26 12:28:55 2019 + +@author: amonl + +Runs +""" + +from instruments import delaystage, lockinamplifier, cryostat + +"""ROT SCAN""" +import numpy as np +import matplotlib +import time +import h5py + + +class Rotscan_measurements(object): + def __init__(self): + self.lockin_amplifier = lockinamplifier.SR830_Ethernet('169.254.88.32', 1234) + self.rot_stage = delaystage.ThorLabs_rotational_stage() + self.cryostat = cryostat.ITC503s() + + def init_instruments(self): + #self.lockin_amplifier.ser.port='COM4' + #self.lockin_amplifier.port= 1234 #'COM6' + #self.lockin_amplifier.GPIB_adress = 8 + #self.host = "169.254.88.32" + self.lockin_amplifier.connect() + self.cryostat.connect() + self.rot_stage.connect() + time.sleep(2) # TODO: move to inside stage class + + def create_points(self, N): + Points = [] + step = 360 / N + for i in range(0, N): + Points.append(i * step) + return Points + + + @staticmethod + def save(name, X, Y): + File = h5py.File(name + time.ctime().replace(':','-') + ".h5", "w") + data = np.array([X, Y]) + dset = File.create_dataset("rotscan", (len(X), 2)) + dset[...] = data.T + File.close() + np.savetxt(name + time.ctime().replace(':', '-') + 'txt.txt', (X,Y)) + + def rotscan_measure(self, name, N_steps, save=False, time_constant=100, var='Y'): + self.init_instruments() + #time.sleep(3) + X = self.create_points(N_steps) + Y = [] + for item in X: + self.rot_stage.move_absolute(item) + #time.sleep(3*time_constant) + Y.append(self.lockin_amplifier.measure_avg(sleep=time_constant, var=var)) + self.lockin_amplifier.disconnect() + matplotlib.pyplot.plot(X, Y) + if save: + self.save(name +'-'+str(N_steps), X, Y) + return X, Y + + + def temperaturescan_measure(self, name, angle, T_List, save=False, time_constant=1, var='Y'): + self.init_instruments() + self.rot_stage.move_absolute(angle) + #time.sleep(3) + X = T_List + Y = [] + for item in X: + self.cryostat.change_temperature(item) + #time.sleep(3*time_constant) + Y.append(self.lockin_amplifier.measure_avg(sleep=time_constant, var=var)) + self.lockin_amplifier.disconnect() + matplotlib.pyplot.plot(X, Y) + if save: + self.save(name +'-'+str(N_steps), X, Y) + return X, Y + + + def finish(self): + self.lockin_amplifier.disconnect() + self.rot_stage.disconnect() + self.cryostat.disconnect() + + +# %% +def main(): + + temperature = 290 + + meas = Rotscan_measurements() + meas.init_instruments() + #or temperature in range(297,305): + # meas.cryostat.connect() + # meas.cryostat.change_temperature(temperature) + # meas.cryostat.disconnect() + + file_name = 'test'#+str(temperature) + meas.cryostat.change_temperature(temperature) + meas.rotscan_measure(file_name, 18) + meas.finish() + + ''' + + T_List = [290, 305] + angle = 0 + + meas = Rotscan_measurements() + meas.init_instruments() + #or temperature in range(297,305): + # meas.cryostat.connect() + # meas.cryostat.change_temperature(temperature) + # meas.cryostat.disconnect() + + file_name = 'test'#+str(temperature) + meas.rot_stage.move_absolute(item) + meas.temperaturescan_measure(file_name, angle, T_List) + meas.finish() + + ''' # move these ''' right below 'def main()' + + + +if __name__ == '__main__': + main() diff --git a/RotScanTest.py b/RotScanTest.py index 60bd3db..72c359a 100644 --- a/RotScanTest.py +++ b/RotScanTest.py @@ -21,13 +21,13 @@ class Rotscan_measurements(object): def __init__(self): #self.lockin_amplifier = lockinamplifier.SR830() self.rot_stage = delaystage.ThorLabs_rotational_stage() - self.cryostat = cryostat.ITC503s(COMport='COM5') + #self.cryostat = cryostat.ITC503s(COMport='COM5') def init_instruments(self): #self.lockin_amplifier.ser.port='COM4' #self.lockin_amplifier.connect() - self.cryostat.connect() + #self.cryostat.connect() ## Magnet=CurrentSupplyLib.CurrentSUP() ## Magnet.initcurrentsupply() ## Magnet.SetVoltage(40) @@ -35,6 +35,7 @@ def init_instruments(self): ## Magnet.SwitchForward() self.rot_stage.connect() time.sleep(2) # TODO: move to inside stage class + self.rot_stage.move_absolute(180) def create_points(self, N): Points = [] @@ -100,17 +101,18 @@ def main(): N_angles = 6 meas = Rotscan_measurements() + print(1) meas.init_instruments() #or temperature in range(297,305): # meas.cryostat.connect() # meas.cryostat.change_temperature(temperature) # meas.cryostat.disconnect() - file_name = 'test'#+str(temperature) + """file_name = 'test'#+str(temperature) meas.cryostat.change_temperature(temperature) meas.cryostat.disconnect() meas.rotscan_measure(file_name, N_angles, save) - meas.finish() + meas.finish()""" ''' diff --git a/instruments/lockinamplifier.py b/instruments/lockinamplifier.py index 5f27cbf..005184d 100644 --- a/instruments/lockinamplifier.py +++ b/instruments/lockinamplifier.py @@ -25,6 +25,7 @@ import numpy as np import serial +import socket import sys sys.path.insert(0,'./..') @@ -982,6 +983,993 @@ def phase(self, value): '\n Local value of {} changed from {} ' 'to {}\n'.format(setting, old_val, value)) self._settings[setting]['value'] = value + + + + + + + + + + + + + + +class SR830_Ethernet(LockInAmplifier): + #host IP has to be adapted by hand at end of __init__ + """ + Unfinished, but works for rotscan + """ + + def __init__(self, host, port, timeout = 100): + super().__init__() + self.logger = logging.getLogger('{}.SR830'.format(__name__)) + self.logger.info('Created instance of SR830 Lock-In Amplifier.') + + self.name = 'SR830 Lock-In Amplifier' + self._settings = { + 'sensitivity': {'value': 2E-9, + 'allowed_values': [2E-9, 5E-9, 1E-8, 2E-8, 5E-8, 1E-7, + 2E-7, 5E-7, 1E-6, 2E-6, 5E-6, 1E-5, + 2E-5, 5E-5, 1E-4, 2E-4, 5E-4, 1E-3, + 2E-3, 5E-3, 1E-2, 2E-2, 5E-2, 1E-1, + 2E-1, 5E-1, 1.], + 'unit': 'V or A', + 'cmd': 'SENS', + }, + 'time_constant': {'value': 3E-1, + 'allowed_values': [1E-5, 3e-5, 1E-4, 3e-4, 1E-3, 3e-3, + 1E-2, 3e-2, 1E-1, 3e-1, 1., 3., + 1E1, 3e1, 1E2, 3e2, 1E3, 3e3, 1E4, 3E4], + 'unit': 's', + 'cmd': 'OFLT', + }, + 'low_pass_filter_slope': {'value': 6, + 'allowed_values': [6, 12, 18, 24], + 'unit': 'dB', + 'cmd': 'OFSL', + }, + 'input_config': {'value': 'A', + 'allowed_values': ['A', 'A-B', 'I(1mOm)', 'I(100mOm)'], + 'unit': '', + 'cmd': 'OFSL', + }, + 'input_shield': {'value': 'Float', + 'allowed_values': ['Float', 'Ground'], + 'unit': '', + 'cmd': 'IGND', + }, + 'input_coupling': {'value': 'AC', + 'allowed_values': ['AC', 'DC'], + 'unit': '', + 'cmd': 'ICPL', + }, + 'input_line_notch_filter': {'value': 'AC', + 'allowed_values': ['no filters', 'Line notch', + '2xLine notch', 'Both notch'], + 'unit': '', + 'cmd': 'ILIN', + }, + 'reserve_mode': {'value': 'High Reserve', + 'allowed_values': ['High Reserve', 'Normal', 'Low Noise'], + 'unit': '', + 'cmd': 'RMOD', + }, + 'synchronous_filter': {'value': 'Off', + 'allowed_values': ['Off', 'Below 200Hz'], + 'unit': '', + 'cmd': 'SYNC', + }, + 'phase': {'value': 0., + 'allowed_values': None, + 'unit': '', + 'cmd': 'PHAS', + }, + 'reference_source': {'value': 'Off', + 'allowed_values': ['Internal', 'External'], + 'unit': '', + 'cmd': 'FMOD', + }, + 'frequency': {'value': 1., + 'allowed_values': None, + 'unit': '', + 'cmd': 'FREQ', + }, + 'reference_trigger': {'value': 'Zero crossing', + 'allowed_values': ['Zero crossing', 'Rising edge', 'Falling edge'], + 'unit': '', + 'cmd': 'RSPL', + }, + 'detection_harmonic': {'value': 1, + 'allowed_values': None, + 'unit': '', + 'cmd': 'HARM', + }, + 'sine_output_amplitude': {'value': 2, + 'allowed_values': ['Zero crossing', 'Rising edge', 'Falling edge'], + 'unit': '', + 'cmd': 'SLVL', + }, + + } + + # Connectivity: + self.port = port #1234 #integer, always 1234 afaik + self.GPIB_address = 8 #set on devce + self.host = host#"169.254.88.32" #static IP assigned to adapter (not the IP from IPconfig) + self.socket = socket.socket(socket.AF_INET, + socket.SOCK_STREAM, + socket.IPPROTO_TCP) + self.timeout = timeout #anything between 0.1 and 100(or more) + + self.socket.settimeout(10) + + # settings + self.should_sync = True # to keep track if all settings are up to date with device state + self.output_dict = {'X': 1, 'Y': 2, 'R': 3, 'Theta': 4, 'Aux1': 5, 'Aux2': 6, 'Aux3': 7, + 'Aux4': 8, 'Reference Frequency': 9, 'CH1 display': 10, 'CH2 diplay': 11} + self._channel_names = ['X', 'Y', 'R', 'Theta', 'Aux1', 'Aux2', 'Aux3', + 'Aux4', 'Reference Frequency', 'CH1 display', + 'CH2 diplay'] + + @property + def connected(self): + """ test if the lock-in amplifier is connected and read/write is allowed. + + :return: + answer: bool + True: locking is connected. False: Locking is NOT connected + """ + self.logger.debug('testing if lockin is connected and responds.') + if self._connected: + try: + val = self.query( + '++ver\r\n'.encode('utf-8')) # query version of the prologix USB-GPIB adapter to test connection + #print(val) + self.logger.debug('SR830 Lockin is Connected') + return True + except Exception: + self.logger.critical('Lockin unexpectedly disconnected!!') + return False + else: + self.logger.debug('SR830 Lockin is NOT connected') + return False + + def connect(self): + """ connect to LockInAmplifier through Prologix USB-GPIB adapter + + Set up the the connection with USB to GPIB adapter, opens port, sets up adater for communication with Lokin SR830m + After using LockInAmplifier use Disconnect function to close the port + """ + self.logger.debug( + 'attempting to connect to SR830 through Prologix adapter. port:{}, GPIB:{}'.format(self.port, + self.GPIB_address)) + try: + self.socket.connect((self.host, self.port)) + #self._setup() + + + self.logger.debug('serial open') + + + self._connected=True #before query + self._setup() + + secret = self.recV() + + #for testing removed (???) + """ + + + + print("here") + value = self.only_query('++ver', 1024) #\r\n') # query version of the prologix Ethernet-GPIB adapter to test connection + print(value) + + + self.logger.info('Encoder version: {}'.format(value)) + # self.socket.close() + + #??? important?: + self.write('++eoi 1') # enable the eoi signal mode, which signals about and of the line + #self.write( + # '++eos 2') # sets up the terminator wich will be added to every command for LockInAmplifier, this is only for GPIB connetction + """ + + """ + !!!!!!!!! + GPIB selection here (Following lines before except) + removed for first experiments but should work + + !!!!!!!! + """ + #self.select(self.GPIB_address) #self.write('++addr' + str(self.GPIB_address)) + #self.logger.debug('assigned GPIB address to {}'.format(self.GPIB_address)) + #idn = self.read('*IDN?') + #self.logger.debug('IDN response from lockin: {}'.format(idn)) + + except Exception as e: + self.socket.close() + self.logger.error('Connection Error: {} - Closing serial port'.format(e), exc_info=True) + + def close(self): + self.socket.close() + + def select(self, addr): + self._send('++addr %i' % int(addr)) + + + def write(self, command): + """ Send any command to the opened port in right format. + + Comands which started with ++ goes to the prologix adapter, others go directly to device(LockInAmplifier) + """ + + if not self._connected: + raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + try: + #self._recv(1024) + self._send(command) + except Exception as e: + self.disconnect() + self.logger.error('Couldnt write command: error - {}\n'.format(e), exc_info=True) + + def read(self, command, num_bytes = 1024): + self._send(command) + return self.simple_read() + + + def complex_read(self, command, num_bytes=1024): + """reads any information from lockin, input command should be query command for lockin, see manual. + : parameters : + command: str + command string to send to lockin + : return : + value: + answer from lockin as byte + """ + + if not self._connected: + raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + + try: + self._recv(num_bytes) #clears output for next command + self._send(command) + + self._send('++read eoi') # maybe this is not needed, but it probably is + + value = self._recv(num_bytes) + self.logger.debug('serial response: {}'.format(value)) + print(value) + + return value + + except Exception as e: + self.disconnect() + self.logger.error('Couldnt read command:: error - {}\n'.format(e), exc_info=True) + + """ + test behavior of value reading in query, maybe some cheating needed ??? + """ + + def simple_read(self, num_bytes=1024): + self._send('++read eoi') + return self._recv(num_bytes) + + + def query(self, cmd, buffer_size=1024*1024):#*1024): # like read but bigger buffer size + print("sending query") + #dump = self.recV() + #print(self.read(buffer_size)) #clears output for next output + + #print("output cleared") + self.write(cmd) + return self.simple_read(buffer_size) + + + + + + #def _send(self, value): + # self.socket.send(('%s\n' % value).encode('utf-8')) + + def _send(self, value): + #encoded_value = ('%s\n' % value).encode('ascii') + encoded_value = (value+"\n").encode("ascii") + self.socket.send(encoded_value) + + def _recv(self, byte_num): + value = self.socket.recv(byte_num) + return value.decode('ascii') + + def recV(self): + return self._recv(1024) + + + def _setup(self): + self._send("++mode 1") #controller mode (0 is device mode) + self._send("++auto 0") #disables read after write (0 adresses device to listen and 1 to talk + self._send('++read_tmo_ms %i' % int(self.timeout*1e3)) #read timeout in ms + self._send('++eos 3') # neither CR or LF are apended to GPIB data + + + def disconnect(self): + """Close com port + """ + self.logger.info('closing serial port') + self._connected = False + self.socket.close() + self.logger.debug('SR830 disconnected.') + + + + def set_to_default(self): + """ Hardware reset Lock-in Amplifier.""" + if not self._connected: + raise DeviceNotConnectedError('Port is closed. Device is not connected.') + self.write('*RST') + + # measurement methods + def measure(self, parameters='default', return_dict=True): + """ Measure the parameters in the current state + + Args: + parameters: + format (str): return format for this function. 'dict', generates a + dictionary with parameters as keys. 'list' returns a list + containing the values. + Returns: + output (dict): if format='dict'. keys are the parameter names, + values are floats representing the numbers returned by the + lockin + list (list): list of float values as returned by the lockin. + """ + + if not self._connected: raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + if parameters == 'default': + parameters = ['X', 'Y', 'Aux1', 'Aux2', 'Aux3', 'Aux4'] + # calculate sleep time from memory, without asking the lockin.+ + dwell = self.get_setting('time_constant') * self._dwell_time_factor + self.logger.info('Lockin dwelling {}s'.format(dwell)) + time.sleep(dwell) + + values = self.read_snap(parameters) + + if return_dict: + output = {} + for idx, item in enumerate(parameters): + output[item] = float(values[idx]) # compose dictionary of values(float) + return output + else: + return values + + def read_value(self, parameter): + """Reads measured value from lockin. + + Parametr is a string like in manual. except Theta. Che the dictionary of parametrs for Output + + : parameters : + Parameter: str + string for communication as given in the manual. + : return : + value: float + value output by the lockin + """ + assert parameter in self.output_dict, '{} is not a valid parameter to read from the SR830'.format(parameter) + Command = 'OUTP ?' + str(self.output_dict[parameter]) + Value = float(self.read(Command)) # returns value as a float + print(str(Value) + ' V') + return Value + + def read_snap(self, parameters): + """Read chosen Values from LockInAmplifier simultaneously. + + : parameters : + parameters: list of strings + Parameters is a list of strings from outputDict. Should be at least 2 + :return: + output: list of float + list corresponding in position to the parameters given. + """ + if not self._connected: raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + assert isinstance(parameters, list), 'parameters need to be a tuple or list' + assert False not in [isinstance(x, str) for x in parameters], 'items in the list must be strings' + assert 2 <= len(parameters) <= 6, 'read_snap requires 2 to 6 parameters' + command = 'SNAP ? ' + #parameters.sort(key=self.sortparam) + for item in parameters: + # compose command string with parameters in input + command = command + str(self._channel_names.index(item)+1) + ', ' + command = command[:-2] # cut last ', ' + print(command) + string = str(self.read(command))[2:-3] # reads answer, transform it to string, cut system characters + print(string) + values = [float(x) for x in string.split(',')] # split answer to separated values and turn them to floats + self.logger.info('Read_Snap: {} for {}'.format(values, parameters)) + return values + + + + def measure_avg(self, avg=10, sleep=None, var='R'): + ''' [DEPRECATED] Perform one action of mesurements, average signal(canceling function in case of not real values should be implemeted), sleep time could be set manualy or automaticaly sets tim constant of lockin x 3''' + self.logger.warning('[DEPRECATED] Using method "measure_avg" which is Deprecated') + + if sleep == None: + sleeptime = self.time_constant + sleep = float(sleeptime) + + signal = [] + time.sleep(3*sleep) + for i in range(avg): + signal.append(self.read_value(var)) + val = sum(signal) / avg + return val + + + + # settings property generators: + @property + def sensitivity(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'sensitivity' + try: + command = self._settings[setting]['cmd'] + ' ?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @sensitivity.setter + def sensitivity(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'sensitivity' + try: + cmd = self._settings[setting]['cmd'] + cmd += ' '+str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def time_constant(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'time_constant' + try: + command = self._settings[setting]['cmd'] + ' ?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @time_constant.setter + def time_constant(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'time_constant' + assert value in self._settings[setting]['allowed_values'] + try: + cmd = self._settings[setting]['cmd'] + cmd += ' '+str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def low_pass_filter_slope(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'low_pass_filter_slope' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @low_pass_filter_slope.setter + def low_pass_filter_slope(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'low_pass_filter_slope' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_config(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_config' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_config.setter + def input_config(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_config' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_shield(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_shield' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_shield.setter + def input_shield(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_shield' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_coupling(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_coupling' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_coupling.setter + def input_coupling(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_coupling' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_line_notch_filter(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_line_notch_filter' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_line_notch_filter.setter + def input_line_notch_filter(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_line_notch_filter' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reserve_mode(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reserve_mode' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reserve_mode.setter + def reserve_mode(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reserve_mode' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def synchronous_filter(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'synchronous_filter' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @synchronous_filter.setter + def synchronous_filter(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'synchronous_filter' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reference_source(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reference_source' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reference_source.setter + def reference_source(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reference_source' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reference_trigger(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reference_trigger' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reference_trigger.setter + def reference_trigger(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reference_trigger' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def sine_output_amplitude(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'sine_output_amplitude' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @sine_output_amplitude.setter + def sine_output_amplitude(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'sine_output_amplitude' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def detection_harmonic(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'detection_harmonic' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @detection_harmonic.setter + def detection_harmonic(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'detection_harmonic' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def frequency(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'frequency' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @frequency.setter + def frequency(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'frequency' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def phase(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'phase' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @phase.setter + def phase(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'phase' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + + + + if __name__ == '__main__': From dcd7263aa864061bfc3ba348e106dfcb246ae6f1 Mon Sep 17 00:00:00 2001 From: redred Date: Tue, 22 Oct 2019 13:29:02 +0200 Subject: [PATCH 2/6] Plot updating during rot measurement --- RotScan.py | 16 +++++++++++++++- RotScanTest.py | 24 ++++++++++++++++++++++-- 2 files changed, 37 insertions(+), 3 deletions(-) diff --git a/RotScan.py b/RotScan.py index e6d7ede..fca043c 100644 --- a/RotScan.py +++ b/RotScan.py @@ -12,6 +12,9 @@ """ROT SCAN""" import numpy as np import matplotlib +import matplotlib.pyplot as plt +#import matplotlib.animation as animation +from matplotlib import style import time import h5py @@ -49,15 +52,26 @@ def save(name, X, Y): File.close() np.savetxt(name + time.ctime().replace(':', '-') + 'txt.txt', (X,Y)) - def rotscan_measure(self, name, N_steps, save=False, time_constant=100, var='Y'): + def rotscan_measure(self, name, N_steps, save=False, time_constant=100, var='Y'): #ggf. save =True self.init_instruments() #time.sleep(3) X = self.create_points(N_steps) + x_tmp =[] Y = [] + style.use("fivethirtyeight") + fig = plt.gcf() + fig.show() + fig.canvas.draw() + + for item in X: self.rot_stage.move_absolute(item) #time.sleep(3*time_constant) + x_tmp.append(item) Y.append(self.lockin_amplifier.measure_avg(sleep=time_constant, var=var)) + plt.plot(x_tmp, Y) + plt.pause(0.01) + fig.canvas.draw() self.lockin_amplifier.disconnect() matplotlib.pyplot.plot(X, Y) if save: diff --git a/RotScanTest.py b/RotScanTest.py index 72c359a..ab3f9d4 100644 --- a/RotScanTest.py +++ b/RotScanTest.py @@ -35,7 +35,7 @@ def init_instruments(self): ## Magnet.SwitchForward() self.rot_stage.connect() time.sleep(2) # TODO: move to inside stage class - self.rot_stage.move_absolute(180) + #self.rot_stage.move_absolute(180) def create_points(self, N): Points = [] @@ -90,11 +90,21 @@ def rotscan_measure(self, name, N_steps, save=False, time_constant=1, var='Y'): def finish(self): #self.lockin_amplifier.disconnect() self.rot_stage.disconnect() - self.cryostat.disconnect() + #self.cryostat.disconnect() # %% def main(): + + def turn(x): + for i in range(2): + meas.rot_stage.move_absolute(x+0) + meas.rot_stage.move_absolute(x+90) + meas.rot_stage.move_absolute(x+180) + meas.rot_stage.move_absolute(x+270) + + def turnto(x): + meas.rot_stage.move_absolute(x) temperature = 295.5 save = False @@ -103,6 +113,12 @@ def main(): meas = Rotscan_measurements() print(1) meas.init_instruments() + + turn(121) + #meas.rot_stage.move_absolute(125+180) + + + meas.finish() #or temperature in range(297,305): # meas.cryostat.connect() # meas.cryostat.change_temperature(temperature) @@ -133,6 +149,10 @@ def main(): ''' # move these ''' right below 'def main()' + + + + if __name__ == '__main__': main() From 4889fbca95ebcd9e929ee68aa38d89c7bae775ab Mon Sep 17 00:00:00 2001 From: redred Date: Wed, 30 Oct 2019 17:11:55 +0100 Subject: [PATCH 3/6] nothin important, #-et out the cryo in rotscan --- RotScan.py | 30 ++++++++++++++++++------------ RotScanTest.py | 2 +- instruments/lockinamplifier.py | 1 + 3 files changed, 20 insertions(+), 13 deletions(-) diff --git a/RotScan.py b/RotScan.py index fca043c..8c8fc06 100644 --- a/RotScan.py +++ b/RotScan.py @@ -23,7 +23,7 @@ class Rotscan_measurements(object): def __init__(self): self.lockin_amplifier = lockinamplifier.SR830_Ethernet('169.254.88.32', 1234) self.rot_stage = delaystage.ThorLabs_rotational_stage() - self.cryostat = cryostat.ITC503s() + #self.cryostat = cryostat.ITC503s() def init_instruments(self): #self.lockin_amplifier.ser.port='COM4' @@ -31,7 +31,7 @@ def init_instruments(self): #self.lockin_amplifier.GPIB_adress = 8 #self.host = "169.254.88.32" self.lockin_amplifier.connect() - self.cryostat.connect() + #self.cryostat.connect() self.rot_stage.connect() time.sleep(2) # TODO: move to inside stage class @@ -58,22 +58,27 @@ def rotscan_measure(self, name, N_steps, save=False, time_constant=100, var='Y') X = self.create_points(N_steps) x_tmp =[] Y = [] - style.use("fivethirtyeight") + print("we here") + """style.use("fivethirtyeight") fig = plt.gcf() fig.show() - fig.canvas.draw() + fig.canvas.draw() """ for item in X: self.rot_stage.move_absolute(item) + print("moved") #time.sleep(3*time_constant) x_tmp.append(item) - Y.append(self.lockin_amplifier.measure_avg(sleep=time_constant, var=var)) - plt.plot(x_tmp, Y) - plt.pause(0.01) - fig.canvas.draw() + Y.append(self.lockin_amplifier.measure_avg(sleep=1, var=var)) + print(Y) + #plt.plot(x_tmp, Y) + #plt.pause(0.01) + #fig.canvas.draw() self.lockin_amplifier.disconnect() - matplotlib.pyplot.plot(X, Y) + #matplotlib.pyplot.plot(X, Y) + print(X) + print(Y) if save: self.save(name +'-'+str(N_steps), X, Y) return X, Y @@ -99,13 +104,14 @@ def temperaturescan_measure(self, name, angle, T_List, save=False, time_constant def finish(self): self.lockin_amplifier.disconnect() self.rot_stage.disconnect() - self.cryostat.disconnect() + #self.cryostat.disconnect() # %% def main(): temperature = 290 + stepnumber =18 meas = Rotscan_measurements() meas.init_instruments() @@ -115,8 +121,8 @@ def main(): # meas.cryostat.disconnect() file_name = 'test'#+str(temperature) - meas.cryostat.change_temperature(temperature) - meas.rotscan_measure(file_name, 18) + #for non room temp un-hashtag here meas.cryostat.change_temperature(temperature) + meas.rotscan_measure(file_name, stepnumber) meas.finish() ''' diff --git a/RotScanTest.py b/RotScanTest.py index ab3f9d4..9cda355 100644 --- a/RotScanTest.py +++ b/RotScanTest.py @@ -114,7 +114,7 @@ def turnto(x): print(1) meas.init_instruments() - turn(121) + turnto(121) #meas.rot_stage.move_absolute(125+180) diff --git a/instruments/lockinamplifier.py b/instruments/lockinamplifier.py index 005184d..6c81880 100644 --- a/instruments/lockinamplifier.py +++ b/instruments/lockinamplifier.py @@ -1404,6 +1404,7 @@ def measure_avg(self, avg=10, sleep=None, var='R'): time.sleep(3*sleep) for i in range(avg): signal.append(self.read_value(var)) + print(signal) #!!!! val = sum(signal) / avg return val From e82398c379c8d242aad9329e18df244cc0c4b008 Mon Sep 17 00:00:00 2001 From: redred Date: Tue, 5 Nov 2019 14:14:06 +0100 Subject: [PATCH 4/6] ATM it's working --- RotScan.py | 40 +- instruments/lockinamplifier.py | 21 +- instruments/lockinamplifierOLD.py | 1983 +++++++++++++++++++++++++++++ prologixGPIB_Ethernet_Test.py | 48 + 4 files changed, 2077 insertions(+), 15 deletions(-) create mode 100644 instruments/lockinamplifierOLD.py create mode 100644 prologixGPIB_Ethernet_Test.py diff --git a/RotScan.py b/RotScan.py index 8c8fc06..822fdb3 100644 --- a/RotScan.py +++ b/RotScan.py @@ -33,8 +33,13 @@ def init_instruments(self): self.lockin_amplifier.connect() #self.cryostat.connect() self.rot_stage.connect() + value = self.lockin_amplifier.query('++ver', 1024) + #'++ver\r\n') + print(value) time.sleep(2) # TODO: move to inside stage class - + + + def create_points(self, N): Points = [] step = 360 / N @@ -70,11 +75,12 @@ def rotscan_measure(self, name, N_steps, save=False, time_constant=100, var='Y') print("moved") #time.sleep(3*time_constant) x_tmp.append(item) - Y.append(self.lockin_amplifier.measure_avg(sleep=1, var=var)) + Y.append(self.lockin_amplifier.measure_avg(sleep=1, var="Y")) print(Y) #plt.plot(x_tmp, Y) #plt.pause(0.01) #fig.canvas.draw() + self.lockin_amplifier.disconnect() #matplotlib.pyplot.plot(X, Y) print(X) @@ -83,6 +89,9 @@ def rotscan_measure(self, name, N_steps, save=False, time_constant=100, var='Y') self.save(name +'-'+str(N_steps), X, Y) return X, Y + def readLockin(self): + print(self.lockin_amplifier.query("OUTP ? 1")) + def temperaturescan_measure(self, name, angle, T_List, save=False, time_constant=1, var='Y'): self.init_instruments() @@ -99,6 +108,13 @@ def temperaturescan_measure(self, name, angle, T_List, save=False, time_constant if save: self.save(name +'-'+str(N_steps), X, Y) return X, Y + + def test(self): + print(self.lockin_amplifier.measure_avg(sleep=1, var='Y')) + + def measureAverage(self): + return self.lockin_amplifier.measure_avg(sleep=1, var='Y') + def finish(self): @@ -111,18 +127,34 @@ def finish(self): def main(): temperature = 290 - stepnumber =18 + stepnumber =2 + + data=[] + + Points = [] + step = 360 / stepnumber + for i in range(0, stepnumber): + Points.append(i * step) + meas = Rotscan_measurements() meas.init_instruments() + #meas.readLockin() #or temperature in range(297,305): # meas.cryostat.connect() # meas.cryostat.change_temperature(temperature) # meas.cryostat.disconnect() + for i in Points: + meas.rot_stage.move_absolute(i) + data.append(meas.measureAverage()) + #meas.rot_stage.move_absolute(20) + #meas.test() + print(data) + file_name = 'test'#+str(temperature) #for non room temp un-hashtag here meas.cryostat.change_temperature(temperature) - meas.rotscan_measure(file_name, stepnumber) + #meas.rotscan_measure(file_name, stepnumber) meas.finish() ''' diff --git a/instruments/lockinamplifier.py b/instruments/lockinamplifier.py index 6c81880..ab5f24d 100644 --- a/instruments/lockinamplifier.py +++ b/instruments/lockinamplifier.py @@ -25,7 +25,7 @@ import numpy as np import serial -import socket +import socket #needs to be installed first import sys sys.path.insert(0,'./..') @@ -985,9 +985,8 @@ def phase(self, value): self._settings[setting]['value'] = value - - - + + @@ -996,6 +995,7 @@ def phase(self, value): + class SR830_Ethernet(LockInAmplifier): #host IP has to be adapted by hand at end of __init__ @@ -1278,7 +1278,8 @@ def query(self, cmd, buffer_size=1024*1024):#*1024): # like read but bigger buff def _send(self, value): #encoded_value = ('%s\n' % value).encode('ascii') encoded_value = (value+"\n").encode("ascii") - self.socket.send(encoded_value) + self.socket.send(encoded_value) + def _recv(self, byte_num): value = self.socket.recv(byte_num) @@ -1404,7 +1405,6 @@ def measure_avg(self, avg=10, sleep=None, var='R'): time.sleep(3*sleep) for i in range(avg): signal.append(self.read_value(var)) - print(signal) #!!!! val = sum(signal) / avg return val @@ -1966,11 +1966,10 @@ def phase(self, value): '\n Local value of {} changed from {} ' 'to {}\n'.format(setting, old_val, value)) self._settings[setting]['value'] = value - - - - - + + + + if __name__ == '__main__': diff --git a/instruments/lockinamplifierOLD.py b/instruments/lockinamplifierOLD.py new file mode 100644 index 0000000..6c81880 --- /dev/null +++ b/instruments/lockinamplifierOLD.py @@ -0,0 +1,1983 @@ +# -*- coding: utf-8 -*- +""" +Created on Sat Apr 21 17:11:24 2018 + +@author: Vladimir Grigorev, Steinn Ymir Agustsson + + Copyright (C) 2018 Steinn Ymir Agustsson, Vladimir Grigorev + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +""" +import logging +import time + +import numpy as np +import serial +import socket + +import sys +sys.path.insert(0,'./..') +from instruments import generic + +from utilities.exceptions import DeviceNotConnectedError +from utilities.settings import parse_setting + + +class LockInAmplifier(generic.Instrument): + #__verbose = parse_setting('general', 'verbose') + + def __init__(self): + super(LockInAmplifier, self).__init__() + self.logger = logging.getLogger('{}.LockInAmplifier'.format(__name__)) + self.logger.info('Created instance of fake LockInAmplifier.') + + self.name = 'Fake LockIn Apmlifier' + # list all methods which can be used as measurement functions + self.measurables = ['read_value'] + self._dwell_time_factor = 3 + self._settings = {'time_constant': {'value': .1}} + self._version = 'Fake lockin 0.1' + + def connect(self): + self._connected = True + self.logger.info('Connected Fake LockInAmplifier amplifier.') + + def disconnect(self): + self._connected = False + self.logger.info('Disconnected Fake LockInAmplifier amplifier.') + + def read_value(self, parameter): + """ emulates the read_value method from SR830""" + self.logger.debug('attempting to read value from Fake lokin') + Value = np.random.rand() # returns value as a string, like the lock-in does + print(parameter + ' = ' + str(Value) + ' V') + time.sleep(self.time_constant.value * self._dwell_time_factor) + self.logger.debug('Fake lokin reading complete') + return Value + + @property + def dwell_time_factor(self): + return self._dwell_time_factor + + @dwell_time_factor.setter + def dwell_time_factor(self, val): + assert val > 0, "cannot wait for negative times! travelling back in time!" + self.logger.debug('Dwell time set to {}'.format(val)) + self._dwell_time_factor = val + + @property + def dwell_time(self): + return self.time_constant * self._dwell_time_factor + + @property + def time_constant(self): + return self._settings['time_constant']['value'] + + @time_constant.setter + def time_constant(self, val): + assert val > 0, 'Time constant cannot be negative.' + self._settings['time_constant']['value'] = val + + def measure(self, parameters, return_dict=False): + + if parameters == 'default': + parameters = ['X', 'Y', 'Aux1', 'Aux2', 'Aux3', 'Aux4'] + assert self.connected, 'lockin not connected.' + self.logger.debug( + 'Measuring (fake) parameters {}, returning {}'.format(parameters, 'dict' if return_dict else 'list')) + # sleep for the defined dwell time + + self.logger.debug('waiting dwell time of {}'.format(self.dwell_time)) + time.sleep(self.dwell_time) + # self.logger.debug('Generating random values for each parameter.') + values = list(np.random.randn(len(parameters))) + # self.logger.debug('Values generated: {}'.format(values)) + if return_dict: + output = {} + for idx, item in enumerate(parameters): + output[item] = float(values[idx]) # compose dictionary of values(float) + # self.logger.debug('Measured output: {}'.format(output)) + return output + else: + return values + + +class SR830(LockInAmplifier): + + def __init__(self): + super().__init__() + self.logger = logging.getLogger('{}.SR830'.format(__name__)) + self.logger.info('Created instance of SR830 Lock-In Amplifier.') + + self.name = 'SR830 Lock-In Amplifier' + self._settings = { + 'sensitivity': {'value': 2E-9, + 'allowed_values': [2E-9, 5E-9, 1E-8, 2E-8, 5E-8, 1E-7, + 2E-7, 5E-7, 1E-6, 2E-6, 5E-6, 1E-5, + 2E-5, 5E-5, 1E-4, 2E-4, 5E-4, 1E-3, + 2E-3, 5E-3, 1E-2, 2E-2, 5E-2, 1E-1, + 2E-1, 5E-1, 1.], + 'unit': 'V or A', + 'cmd': 'SENS', + }, + 'time_constant': {'value': 3E-1, + 'allowed_values': [1E-5, 3e-5, 1E-4, 3e-4, 1E-3, 3e-3, + 1E-2, 3e-2, 1E-1, 3e-1, 1., 3., + 1E1, 3e1, 1E2, 3e2, 1E3, 3e3, 1E4, 3E4], + 'unit': 's', + 'cmd': 'OFLT', + }, + 'low_pass_filter_slope': {'value': 6, + 'allowed_values': [6, 12, 18, 24], + 'unit': 'dB', + 'cmd': 'OFSL', + }, + 'input_config': {'value': 'A', + 'allowed_values': ['A', 'A-B', 'I(1mOm)', 'I(100mOm)'], + 'unit': '', + 'cmd': 'OFSL', + }, + 'input_shield': {'value': 'Float', + 'allowed_values': ['Float', 'Ground'], + 'unit': '', + 'cmd': 'IGND', + }, + 'input_coupling': {'value': 'AC', + 'allowed_values': ['AC', 'DC'], + 'unit': '', + 'cmd': 'ICPL', + }, + 'input_line_notch_filter': {'value': 'AC', + 'allowed_values': ['no filters', 'Line notch', + '2xLine notch', 'Both notch'], + 'unit': '', + 'cmd': 'ILIN', + }, + 'reserve_mode': {'value': 'High Reserve', + 'allowed_values': ['High Reserve', 'Normal', 'Low Noise'], + 'unit': '', + 'cmd': 'RMOD', + }, + 'synchronous_filter': {'value': 'Off', + 'allowed_values': ['Off', 'Below 200Hz'], + 'unit': '', + 'cmd': 'SYNC', + }, + 'phase': {'value': 0., + 'allowed_values': None, + 'unit': '', + 'cmd': 'PHAS', + }, + 'reference_source': {'value': 'Off', + 'allowed_values': ['Internal', 'External'], + 'unit': '', + 'cmd': 'FMOD', + }, + 'frequency': {'value': 1., + 'allowed_values': None, + 'unit': '', + 'cmd': 'FREQ', + }, + 'reference_trigger': {'value': 'Zero crossing', + 'allowed_values': ['Zero crossing', 'Rising edge', 'Falling edge'], + 'unit': '', + 'cmd': 'RSPL', + }, + 'detection_harmonic': {'value': 1, + 'allowed_values': None, + 'unit': '', + 'cmd': 'HARM', + }, + 'sine_output_amplitude': {'value': 2, + 'allowed_values': ['Zero crossing', 'Rising edge', 'Falling edge'], + 'unit': '', + 'cmd': 'SLVL', + }, + + } + + # Connectivity: + self.GPIB_address = 8 + self.ser = serial.Serial() + self.ser.baudrate = 9600 + self.ser.port = 'COM6' + self.ser.timeout = 1 + + # settings + self.should_sync = True # to keep track if all settings are up to date with device state + self.output_dict = {'X': 1, 'Y': 2, 'R': 3, 'Theta': 4, 'Aux1': 5, 'Aux2': 6, 'Aux3': 7, + 'Aux4': 8, 'Reference Frequency': 9, 'CH1 display': 10, 'CH2 diplay': 11} + self._channel_names = ['X', 'Y', 'R', 'Theta', 'Aux1', 'Aux2', 'Aux3', + 'Aux4', 'Reference Frequency', 'CH1 display', + 'CH2 diplay'] + + @property + def connected(self): + """ test if the lock-in amplifier is connected and read/write is allowed. + + :return: + answer: bool + True: locking is connected. False: Locking is NOT connected + """ + self.logger.debug('testing if lockin is connected and responds.') + if self._connected: + try: + self.ser.write( + '++ver\r\n'.encode('utf-8')) # query version of the prologix USB-GPIB adapter to test connection + val = self.ser.readline() # reads version + #print(val) + self.logger.debug('SR830 Lockin is Connected') + return True + except Exception: + self.logger.critical('Lockin unexpectedly disconnected!!') + return False + else: + self.logger.debug('SR830 Lockin is NOT connected') + return False + + def connect(self): + """ connect to LockInAmplifier through Prologix USB-GPIB adapter + + Set up the the connection with USB to GPIB adapter, opens port, sets up adater for communication with Lokin SR830m + After using LockInAmplifier use Disconnect function to close the port + """ + self.logger.debug( + 'attempting to connect to SR830 through Prologix adapter. port:{}, GPIB:{}'.format(self.ser.port, + self.GPIB_address)) + try: + self.ser.open() # opens COM port with values in this class, Opens ones so after using use disconnecnt function to close it + self.logger.debug('serial open') + self.ser.write('++ver\r\n'.encode('utf-8')) # query version of the prologix USB-GPIB adapter to test connection + value = self.ser.readline()# reads version + self._connected=True + self.logger.info('Encoder version: {}'.format(value)) + # self.ser.close() + self.write('++eoi 1') # enable the eoi signal mode, which signals about and of the line + self.write( + '++eos 2') # sets up the terminator wich will be added to every command for LockInAmplifier, this is only for GPIB connetction + self.write('++addr' + str(self.GPIB_address)) + self.logger.debug('assigned GPIB address to {}'.format(self.GPIB_address)) + idn = self.read('*IDN?') + self.logger.debug('IDN response from lockin: {}'.format(idn)) + #self._connected = True + except Exception as e: + self.ser.close() + self.logger.error('Connection Error: {} - Closing serial port'.format(e), exc_info=True) + + def disconnect(self): + """Close com port + """ + self.logger.info('closing serial port') + self._connected = False + self.ser.close() + self.logger.debug('SR830 disconnected.') + + def write(self, Command): + """ Send any command to the opened port in right format. + + Comands which started with ++ goes to the prologix adapter, others go directly to device(LockInAmplifier) + """ + if not self.ser.isOpen(): + raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + try: + self.ser.write((Command + '\r\n').encode('utf-8')) + except Exception as e: + self.disconnect() + self.logger.error('Couldnt write command: error - {}\n'.format(e), exc_info=True) + + def read(self, command): + """reads any information from lockin, input command should be query command for lockin, see manual. + : parameters : + command: str + command string to send to lockin + : return : + value: + answer from lockin as byte + """ + if not self._connected: raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + try: + # query info from lockin. adapter reads answer automaticaly and store it + self.write(command) + # query data stored in adapter, eoi means that readin will end as + # soon as special caracter will recieved. without it will read + # before timeout, which slow down reading + self.ser.write(('++read eoi\r\n').encode('utf-8')) + value = self.ser.readline() # reads answer + self.logger.debug('serial response: {}'.format(value)) + print(value) + return value + + except Exception as e: + self.disconnect() + self.logger.error('Couldnt read command:: error - {}\n'.format(e), exc_info=True) + + def set_to_default(self): + """ Hardware reset Lock-in Amplifier.""" + if not self.ser.is_open: + raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + self.write('*RST') + + # measurement methods + def measure(self, parameters='default', return_dict=True): + """ Measure the parameters in the current state + + Args: + parameters: + format (str): return format for this function. 'dict', generates a + dictionary with parameters as keys. 'list' returns a list + containing the values. + Returns: + output (dict): if format='dict'. keys are the parameter names, + values are floats representing the numbers returned by the + lockin + list (list): list of float values as returned by the lockin. + """ + + if not self._connected: raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + if parameters == 'default': + parameters = ['X', 'Y', 'Aux1', 'Aux2', 'Aux3', 'Aux4'] + # calculate sleep time from memory, without asking the lockin.+ + dwell = self.get_setting('time_constant') * self._dwell_time_factor + self.logger.info('Lockin dwelling {}s'.format(dwell)) + time.sleep(dwell) + + values = self.read_snap(parameters) + + if return_dict: + output = {} + for idx, item in enumerate(parameters): + output[item] = float(values[idx]) # compose dictionary of values(float) + return output + else: + return values + + def read_value(self, parameter): + """Reads measured value from lockin. + + Parametr is a string like in manual. except Theta. Che the dictionary of parametrs for Output + + : parameters : + Parameter: str + string for communication as given in the manual. + : return : + value: float + value output by the lockin + """ + assert parameter in self.output_dict, '{} is not a valid parameter to read from the SR830'.format(parameter) + Command = 'OUTP ?' + str(self.output_dict[parameter]) + Value = float(self.read(Command)) # returns value as a float + print(str(Value) + ' V') + return Value + + def read_snap(self, parameters): + """Read chosen Values from LockInAmplifier simultaneously. + + : parameters : + parameters: list of strings + Parameters is a list of strings from outputDict. Should be at least 2 + :return: + output: list of float + list corresponding in position to the parameters given. + """ + if not self._connected: raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + assert isinstance(parameters, list), 'parameters need to be a tuple or list' + assert False not in [isinstance(x, str) for x in parameters], 'items in the list must be strings' + assert 2 <= len(parameters) <= 6, 'read_snap requires 2 to 6 parameters' + command = 'SNAP ? ' + #parameters.sort(key=self.sortparam) + for item in parameters: + # compose command string with parameters in input + command = command + str(self._channel_names.index(item)+1) + ', ' + command = command[:-2] # cut last ', ' + print(command) + string = str(self.read(command))[2:-3] # reads answer, transform it to string, cut system characters + print(string) + values = [float(x) for x in string.split(',')] # split answer to separated values and turn them to floats + self.logger.info('Read_Snap: {} for {}'.format(values, parameters)) + return values + + + + def measure_avg(self, avg=10, sleep=None, var='R'): + ''' [DEPRECATED] Perform one action of mesurements, average signal(canceling function in case of not real values should be implemeted), sleep time could be set manualy or automaticaly sets tim constant of lockin x 3''' + self.logger.warning('[DEPRECATED] Using method "measure_avg" which is Deprecated') + + if sleep == None: + sleeptime = self.time_constant + sleep = float(sleeptime) + + signal = [] + time.sleep(3*sleep) + for i in range(avg): + signal.append(self.read_value(var)) + val = sum(signal) / avg + return val + + + + # settings property generators: + @property + def sensitivity(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'sensitivity' + try: + command = self._settings[setting]['cmd'] + ' ?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @sensitivity.setter + def sensitivity(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'sensitivity' + try: + cmd = self._settings[setting]['cmd'] + cmd += ' '+str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def time_constant(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'time_constant' + try: + command = self._settings[setting]['cmd'] + ' ?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @time_constant.setter + def time_constant(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'time_constant' + assert value in self._settings[setting]['allowed_values'] + try: + cmd = self._settings[setting]['cmd'] + cmd += ' '+str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def low_pass_filter_slope(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'low_pass_filter_slope' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @low_pass_filter_slope.setter + def low_pass_filter_slope(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'low_pass_filter_slope' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_config(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_config' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_config.setter + def input_config(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_config' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_shield(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_shield' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_shield.setter + def input_shield(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_shield' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_coupling(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_coupling' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_coupling.setter + def input_coupling(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_coupling' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_line_notch_filter(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_line_notch_filter' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_line_notch_filter.setter + def input_line_notch_filter(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_line_notch_filter' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reserve_mode(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reserve_mode' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reserve_mode.setter + def reserve_mode(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reserve_mode' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def synchronous_filter(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'synchronous_filter' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @synchronous_filter.setter + def synchronous_filter(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'synchronous_filter' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reference_source(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reference_source' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reference_source.setter + def reference_source(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reference_source' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reference_trigger(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reference_trigger' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reference_trigger.setter + def reference_trigger(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reference_trigger' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def sine_output_amplitude(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'sine_output_amplitude' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @sine_output_amplitude.setter + def sine_output_amplitude(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'sine_output_amplitude' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def detection_harmonic(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'detection_harmonic' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @detection_harmonic.setter + def detection_harmonic(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'detection_harmonic' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def frequency(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'frequency' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @frequency.setter + def frequency(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'frequency' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def phase(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'phase' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @phase.setter + def phase(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'phase' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + + + + + + + + + + + + + +class SR830_Ethernet(LockInAmplifier): + #host IP has to be adapted by hand at end of __init__ + """ + Unfinished, but works for rotscan + """ + + def __init__(self, host, port, timeout = 100): + super().__init__() + self.logger = logging.getLogger('{}.SR830'.format(__name__)) + self.logger.info('Created instance of SR830 Lock-In Amplifier.') + + self.name = 'SR830 Lock-In Amplifier' + self._settings = { + 'sensitivity': {'value': 2E-9, + 'allowed_values': [2E-9, 5E-9, 1E-8, 2E-8, 5E-8, 1E-7, + 2E-7, 5E-7, 1E-6, 2E-6, 5E-6, 1E-5, + 2E-5, 5E-5, 1E-4, 2E-4, 5E-4, 1E-3, + 2E-3, 5E-3, 1E-2, 2E-2, 5E-2, 1E-1, + 2E-1, 5E-1, 1.], + 'unit': 'V or A', + 'cmd': 'SENS', + }, + 'time_constant': {'value': 3E-1, + 'allowed_values': [1E-5, 3e-5, 1E-4, 3e-4, 1E-3, 3e-3, + 1E-2, 3e-2, 1E-1, 3e-1, 1., 3., + 1E1, 3e1, 1E2, 3e2, 1E3, 3e3, 1E4, 3E4], + 'unit': 's', + 'cmd': 'OFLT', + }, + 'low_pass_filter_slope': {'value': 6, + 'allowed_values': [6, 12, 18, 24], + 'unit': 'dB', + 'cmd': 'OFSL', + }, + 'input_config': {'value': 'A', + 'allowed_values': ['A', 'A-B', 'I(1mOm)', 'I(100mOm)'], + 'unit': '', + 'cmd': 'OFSL', + }, + 'input_shield': {'value': 'Float', + 'allowed_values': ['Float', 'Ground'], + 'unit': '', + 'cmd': 'IGND', + }, + 'input_coupling': {'value': 'AC', + 'allowed_values': ['AC', 'DC'], + 'unit': '', + 'cmd': 'ICPL', + }, + 'input_line_notch_filter': {'value': 'AC', + 'allowed_values': ['no filters', 'Line notch', + '2xLine notch', 'Both notch'], + 'unit': '', + 'cmd': 'ILIN', + }, + 'reserve_mode': {'value': 'High Reserve', + 'allowed_values': ['High Reserve', 'Normal', 'Low Noise'], + 'unit': '', + 'cmd': 'RMOD', + }, + 'synchronous_filter': {'value': 'Off', + 'allowed_values': ['Off', 'Below 200Hz'], + 'unit': '', + 'cmd': 'SYNC', + }, + 'phase': {'value': 0., + 'allowed_values': None, + 'unit': '', + 'cmd': 'PHAS', + }, + 'reference_source': {'value': 'Off', + 'allowed_values': ['Internal', 'External'], + 'unit': '', + 'cmd': 'FMOD', + }, + 'frequency': {'value': 1., + 'allowed_values': None, + 'unit': '', + 'cmd': 'FREQ', + }, + 'reference_trigger': {'value': 'Zero crossing', + 'allowed_values': ['Zero crossing', 'Rising edge', 'Falling edge'], + 'unit': '', + 'cmd': 'RSPL', + }, + 'detection_harmonic': {'value': 1, + 'allowed_values': None, + 'unit': '', + 'cmd': 'HARM', + }, + 'sine_output_amplitude': {'value': 2, + 'allowed_values': ['Zero crossing', 'Rising edge', 'Falling edge'], + 'unit': '', + 'cmd': 'SLVL', + }, + + } + + # Connectivity: + self.port = port #1234 #integer, always 1234 afaik + self.GPIB_address = 8 #set on devce + self.host = host#"169.254.88.32" #static IP assigned to adapter (not the IP from IPconfig) + self.socket = socket.socket(socket.AF_INET, + socket.SOCK_STREAM, + socket.IPPROTO_TCP) + self.timeout = timeout #anything between 0.1 and 100(or more) + + self.socket.settimeout(10) + + # settings + self.should_sync = True # to keep track if all settings are up to date with device state + self.output_dict = {'X': 1, 'Y': 2, 'R': 3, 'Theta': 4, 'Aux1': 5, 'Aux2': 6, 'Aux3': 7, + 'Aux4': 8, 'Reference Frequency': 9, 'CH1 display': 10, 'CH2 diplay': 11} + self._channel_names = ['X', 'Y', 'R', 'Theta', 'Aux1', 'Aux2', 'Aux3', + 'Aux4', 'Reference Frequency', 'CH1 display', + 'CH2 diplay'] + + @property + def connected(self): + """ test if the lock-in amplifier is connected and read/write is allowed. + + :return: + answer: bool + True: locking is connected. False: Locking is NOT connected + """ + self.logger.debug('testing if lockin is connected and responds.') + if self._connected: + try: + val = self.query( + '++ver\r\n'.encode('utf-8')) # query version of the prologix USB-GPIB adapter to test connection + #print(val) + self.logger.debug('SR830 Lockin is Connected') + return True + except Exception: + self.logger.critical('Lockin unexpectedly disconnected!!') + return False + else: + self.logger.debug('SR830 Lockin is NOT connected') + return False + + def connect(self): + """ connect to LockInAmplifier through Prologix USB-GPIB adapter + + Set up the the connection with USB to GPIB adapter, opens port, sets up adater for communication with Lokin SR830m + After using LockInAmplifier use Disconnect function to close the port + """ + self.logger.debug( + 'attempting to connect to SR830 through Prologix adapter. port:{}, GPIB:{}'.format(self.port, + self.GPIB_address)) + try: + self.socket.connect((self.host, self.port)) + #self._setup() + + + self.logger.debug('serial open') + + + self._connected=True #before query + self._setup() + + secret = self.recV() + + #for testing removed (???) + """ + + + + print("here") + value = self.only_query('++ver', 1024) #\r\n') # query version of the prologix Ethernet-GPIB adapter to test connection + print(value) + + + self.logger.info('Encoder version: {}'.format(value)) + # self.socket.close() + + #??? important?: + self.write('++eoi 1') # enable the eoi signal mode, which signals about and of the line + #self.write( + # '++eos 2') # sets up the terminator wich will be added to every command for LockInAmplifier, this is only for GPIB connetction + """ + + """ + !!!!!!!!! + GPIB selection here (Following lines before except) + removed for first experiments but should work + + !!!!!!!! + """ + #self.select(self.GPIB_address) #self.write('++addr' + str(self.GPIB_address)) + #self.logger.debug('assigned GPIB address to {}'.format(self.GPIB_address)) + #idn = self.read('*IDN?') + #self.logger.debug('IDN response from lockin: {}'.format(idn)) + + except Exception as e: + self.socket.close() + self.logger.error('Connection Error: {} - Closing serial port'.format(e), exc_info=True) + + def close(self): + self.socket.close() + + def select(self, addr): + self._send('++addr %i' % int(addr)) + + + def write(self, command): + """ Send any command to the opened port in right format. + + Comands which started with ++ goes to the prologix adapter, others go directly to device(LockInAmplifier) + """ + + if not self._connected: + raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + try: + #self._recv(1024) + self._send(command) + except Exception as e: + self.disconnect() + self.logger.error('Couldnt write command: error - {}\n'.format(e), exc_info=True) + + def read(self, command, num_bytes = 1024): + self._send(command) + return self.simple_read() + + + def complex_read(self, command, num_bytes=1024): + """reads any information from lockin, input command should be query command for lockin, see manual. + : parameters : + command: str + command string to send to lockin + : return : + value: + answer from lockin as byte + """ + + if not self._connected: + raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + + try: + self._recv(num_bytes) #clears output for next command + self._send(command) + + self._send('++read eoi') # maybe this is not needed, but it probably is + + value = self._recv(num_bytes) + self.logger.debug('serial response: {}'.format(value)) + print(value) + + return value + + except Exception as e: + self.disconnect() + self.logger.error('Couldnt read command:: error - {}\n'.format(e), exc_info=True) + + """ + test behavior of value reading in query, maybe some cheating needed ??? + """ + + def simple_read(self, num_bytes=1024): + self._send('++read eoi') + return self._recv(num_bytes) + + + def query(self, cmd, buffer_size=1024*1024):#*1024): # like read but bigger buffer size + print("sending query") + #dump = self.recV() + #print(self.read(buffer_size)) #clears output for next output + + #print("output cleared") + self.write(cmd) + return self.simple_read(buffer_size) + + + + + + #def _send(self, value): + # self.socket.send(('%s\n' % value).encode('utf-8')) + + def _send(self, value): + #encoded_value = ('%s\n' % value).encode('ascii') + encoded_value = (value+"\n").encode("ascii") + self.socket.send(encoded_value) + + def _recv(self, byte_num): + value = self.socket.recv(byte_num) + return value.decode('ascii') + + def recV(self): + return self._recv(1024) + + + def _setup(self): + self._send("++mode 1") #controller mode (0 is device mode) + self._send("++auto 0") #disables read after write (0 adresses device to listen and 1 to talk + self._send('++read_tmo_ms %i' % int(self.timeout*1e3)) #read timeout in ms + self._send('++eos 3') # neither CR or LF are apended to GPIB data + + + def disconnect(self): + """Close com port + """ + self.logger.info('closing serial port') + self._connected = False + self.socket.close() + self.logger.debug('SR830 disconnected.') + + + + def set_to_default(self): + """ Hardware reset Lock-in Amplifier.""" + if not self._connected: + raise DeviceNotConnectedError('Port is closed. Device is not connected.') + self.write('*RST') + + # measurement methods + def measure(self, parameters='default', return_dict=True): + """ Measure the parameters in the current state + + Args: + parameters: + format (str): return format for this function. 'dict', generates a + dictionary with parameters as keys. 'list' returns a list + containing the values. + Returns: + output (dict): if format='dict'. keys are the parameter names, + values are floats representing the numbers returned by the + lockin + list (list): list of float values as returned by the lockin. + """ + + if not self._connected: raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + if parameters == 'default': + parameters = ['X', 'Y', 'Aux1', 'Aux2', 'Aux3', 'Aux4'] + # calculate sleep time from memory, without asking the lockin.+ + dwell = self.get_setting('time_constant') * self._dwell_time_factor + self.logger.info('Lockin dwelling {}s'.format(dwell)) + time.sleep(dwell) + + values = self.read_snap(parameters) + + if return_dict: + output = {} + for idx, item in enumerate(parameters): + output[item] = float(values[idx]) # compose dictionary of values(float) + return output + else: + return values + + def read_value(self, parameter): + """Reads measured value from lockin. + + Parametr is a string like in manual. except Theta. Che the dictionary of parametrs for Output + + : parameters : + Parameter: str + string for communication as given in the manual. + : return : + value: float + value output by the lockin + """ + assert parameter in self.output_dict, '{} is not a valid parameter to read from the SR830'.format(parameter) + Command = 'OUTP ?' + str(self.output_dict[parameter]) + Value = float(self.read(Command)) # returns value as a float + print(str(Value) + ' V') + return Value + + def read_snap(self, parameters): + """Read chosen Values from LockInAmplifier simultaneously. + + : parameters : + parameters: list of strings + Parameters is a list of strings from outputDict. Should be at least 2 + :return: + output: list of float + list corresponding in position to the parameters given. + """ + if not self._connected: raise DeviceNotConnectedError('COM port is closed. Device is not connected.') + assert isinstance(parameters, list), 'parameters need to be a tuple or list' + assert False not in [isinstance(x, str) for x in parameters], 'items in the list must be strings' + assert 2 <= len(parameters) <= 6, 'read_snap requires 2 to 6 parameters' + command = 'SNAP ? ' + #parameters.sort(key=self.sortparam) + for item in parameters: + # compose command string with parameters in input + command = command + str(self._channel_names.index(item)+1) + ', ' + command = command[:-2] # cut last ', ' + print(command) + string = str(self.read(command))[2:-3] # reads answer, transform it to string, cut system characters + print(string) + values = [float(x) for x in string.split(',')] # split answer to separated values and turn them to floats + self.logger.info('Read_Snap: {} for {}'.format(values, parameters)) + return values + + + + def measure_avg(self, avg=10, sleep=None, var='R'): + ''' [DEPRECATED] Perform one action of mesurements, average signal(canceling function in case of not real values should be implemeted), sleep time could be set manualy or automaticaly sets tim constant of lockin x 3''' + self.logger.warning('[DEPRECATED] Using method "measure_avg" which is Deprecated') + + if sleep == None: + sleeptime = self.time_constant + sleep = float(sleeptime) + + signal = [] + time.sleep(3*sleep) + for i in range(avg): + signal.append(self.read_value(var)) + print(signal) #!!!! + val = sum(signal) / avg + return val + + + + # settings property generators: + @property + def sensitivity(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'sensitivity' + try: + command = self._settings[setting]['cmd'] + ' ?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @sensitivity.setter + def sensitivity(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'sensitivity' + try: + cmd = self._settings[setting]['cmd'] + cmd += ' '+str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def time_constant(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'time_constant' + try: + command = self._settings[setting]['cmd'] + ' ?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @time_constant.setter + def time_constant(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'time_constant' + assert value in self._settings[setting]['allowed_values'] + try: + cmd = self._settings[setting]['cmd'] + cmd += ' '+str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def low_pass_filter_slope(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'low_pass_filter_slope' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @low_pass_filter_slope.setter + def low_pass_filter_slope(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'low_pass_filter_slope' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_config(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_config' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_config.setter + def input_config(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_config' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_shield(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_shield' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_shield.setter + def input_shield(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_shield' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_coupling(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_coupling' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_coupling.setter + def input_coupling(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_coupling' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def input_line_notch_filter(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'input_line_notch_filter' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @input_line_notch_filter.setter + def input_line_notch_filter(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'input_line_notch_filter' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reserve_mode(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reserve_mode' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reserve_mode.setter + def reserve_mode(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reserve_mode' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def synchronous_filter(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'synchronous_filter' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @synchronous_filter.setter + def synchronous_filter(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'synchronous_filter' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reference_source(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reference_source' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reference_source.setter + def reference_source(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reference_source' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def reference_trigger(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'reference_trigger' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @reference_trigger.setter + def reference_trigger(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'reference_trigger' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def sine_output_amplitude(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'sine_output_amplitude' + try: + command = self._settings[setting]['cmd'] + '?' + value_idx = int(self.read(command)) + value = self._settings[setting]['allowed_values'][value_idx] + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @sine_output_amplitude.setter + def sine_output_amplitude(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'sine_output_amplitude' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def detection_harmonic(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'detection_harmonic' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @detection_harmonic.setter + def detection_harmonic(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'detection_harmonic' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def frequency(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'frequency' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @frequency.setter + def frequency(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'frequency' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + @property + def phase(self): + """ return the value on lockin or if disconnected the locally set value""" + setting = 'phase' + try: + command = self._settings[setting]['cmd'] + '?' + value = float(self.read(command)) + old_value = self._settings[setting]['value'] + if old_value != value: + self._settings[setting]['value'] = value + self.logger.debug( + 'Local value of {} changed to remote value: was {}, now is {}'.format(setting, old_value, value)) + except DeviceNotConnectedError: + self.logger.warning('Device not connected: returning stored value') + value = self._settings[setting]['value'] + return value + + @phase.setter + def phase(self, value): + """ Set the value on the lockin or if disconnected queue it to be set.""" + setting = 'phase' + assert isinstance(value, float), 'wrong type for detection harmonic' + try: + cmd = self._settings[setting]['cmd'] + cmd += str(self._settings[setting]['allowed_values'].index(value)) + self.write(cmd) + old_val = self._settings[setting]['value'] + self._settings[setting]['value'] = value + self.logger.debug('Local AND Remote value of {} changed from {} ' + 'to {}'.format(setting, old_val, value)) + except DeviceNotConnectedError: + self.should_sync = True + self.logger.warning('Device not connected, couldnt set value remotely.' + '\n Local value of {} changed from {} ' + 'to {}\n'.format(setting, old_val, value)) + self._settings[setting]['value'] = value + + + + + + + +if __name__ == '__main__': + la=SR830() + la.connect() + la.read_value('R') + la.read_snap(['R','X','Y']) + la.disconnect() + + pass diff --git a/prologixGPIB_Ethernet_Test.py b/prologixGPIB_Ethernet_Test.py new file mode 100644 index 0000000..b9bc47e --- /dev/null +++ b/prologixGPIB_Ethernet_Test.py @@ -0,0 +1,48 @@ +# -*- coding: utf-8 -*- +""" +Created on Mon Sep 9 13:46:05 2019 + +@author: amonl +""" + +from instruments import lockinamplifier, delaystage +import time + +class Test_connection(object): + def __init__(self): + self.lockin_amplifier = lockinamplifier.SR830_Ethernet('169.254.88.32', 1234) + self.rot_stage = delaystage.ThorLabs_rotational_stage() + + + def init_instruments(self): + print("connecting") + self.lockin_amplifier.connect() + self.rot_stage.connect() + #self.lockin.port= 1234 #'COM6' + #self.lockin.GPIB_adress = 8 + #self.host = "169.254.88.32" + #print("connecting") + #self.lockin.connect() + print("connected") + value = self.lockin_amplifier.query('++ver', 1024) + #'++ver\r\n') + print(value) + time.sleep(2) # TODO: move to inside stage class + + def test(self): + print(self.lockin_amplifier.measure_avg(sleep=1, var='Y')) + + +def main(): + meas = Test_connection() + meas.init_instruments() + meas.rot_stage.move_absolute(0) + meas.test() + meas.rot_stage.move_absolute(20) + meas.test() + meas.lockin_amplifier.close() + print("done") + + +if __name__ == '__main__': + main() From b168ede623b7108d23c4d020529df0aeff4cd86c Mon Sep 17 00:00:00 2001 From: redred Date: Tue, 5 Nov 2019 15:36:15 +0100 Subject: [PATCH 5/6] saves in D:RotScanTestsNow --- RotScan.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/RotScan.py b/RotScan.py index 822fdb3..eb50ad7 100644 --- a/RotScan.py +++ b/RotScan.py @@ -126,8 +126,12 @@ def finish(self): # %% def main(): + + stepnumber =2 #number of datapoints + saveBool = True #False #True + filename = 'test'#+str(temperature) + temperature = 290 - stepnumber =2 data=[] @@ -150,13 +154,19 @@ def main(): #meas.rot_stage.move_absolute(20) #meas.test() print(data) + plt.plot(Points, data) + plt.show() + - file_name = 'test'#+str(temperature) #for non room temp un-hashtag here meas.cryostat.change_temperature(temperature) #meas.rotscan_measure(file_name, stepnumber) meas.finish() + + if saveBool: + np.savetxt("D:/RotScanTests/" + filename + '.txt', (Points, data)) + ''' T_List = [290, 305] From 4cfa284edb7991173eec302788c116e64e7653df Mon Sep 17 00:00:00 2001 From: redred Date: Thu, 21 Nov 2019 11:09:31 +0100 Subject: [PATCH 6/6] DONT FORGET TO COMMIT!!! --- RotScan.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/RotScan.py b/RotScan.py index eb50ad7..b48611c 100644 --- a/RotScan.py +++ b/RotScan.py @@ -127,7 +127,7 @@ def finish(self): def main(): - stepnumber =2 #number of datapoints + stepnumber =8 #number of datapoints saveBool = True #False #True filename = 'test'#+str(temperature)