def freq_counter_impedance(self, *impedance): if test_flag != 'test': if len(impedance) == 2: ch = str(impedance[0]) imp = str(impedance[1]) if imp in impedance_dict: flag = impedance_dict[imp] if ch == 'CH1': self.device_write(":INPut1:IMPedance " + str(flag)) elif ch == 'CH2': self.device_write(":INPut2:IMPedance " + str(flag)) elif ch == 'CH3': general.message('The impedance for CH3 is only 50 Ohm') elif len(impedance) == 1: ch = str(impedance[0]) if ch == 'CH1': raw_answer = float(self.device_query(":INPut1:IMPedance?")) answer = cutil.search_keys_dictionary( impedance_dict, raw_answer) return answer elif ch == 'CH2': raw_answer = float(self.device_query(":INPut2:IMPedance?")) answer = cutil.search_keys_dictionary( impedance_dict, raw_answer) return answer elif ch == 'CH3': answer = '50' general.message('The impedance for CH3 is only 50 Ohm') return answer else: general.message('Invalid argument') sys.exit() elif test_flag == 'test': if len(impedance) == 2: ch = str(impedance[0]) imp = str(impedance[1]) assert (ch == 'CH1' or ch == 'CH2' or ch == 'CH3'), 'Invalid channel is given' assert (imp in impedance_dict), 'Invalid impedance is given' elif len(impedance) == 1: ch = str(impedance[0]) assert (ch == 'CH1' or ch == 'CH2' or ch == 'CH3'), 'Invalid channel is given' answer = test_impedance return answer else: assert (1 == 2), "Incorrect impedance argument"
def oscilloscope_acquisition_type(self, *ac_type): if test_flag != 'test': if len(ac_type) == 1: at = str(ac_type[0]) if at in ac_type_dic: flag = ac_type_dic[at] self.device_write(":ACQuire:TYPE " + str(flag)) else: general.message("Invalid acquisition type") sys.exit() elif len(ac_type) == 0: raw_answer = str(self.device_query(":ACQuire:TYPE?")) answer = cutil.search_keys_dictionary(ac_type_dic, raw_answer) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(ac_type) == 1: at = str(ac_type[0]) if at in ac_type_dic: flag = ac_type_dic[at] else: assert(1 == 2), "Invalid acquisition type" elif len(ac_type) == 0: answer = test_acquisition_type return answer else: assert (1 == 2), 'Invalid acquisition type argument'
def freq_counter_start_mode(self, *mode): if test_flag != 'test': if len(mode) == 1: md = str(mode[0]) if md in startarm_dic: flag = startarm_dic[md] self.device_write(":FREQuency:ARM:START:SOURce " + str(flag)) else: general.message("Invalid start arm mode") sys.exit() elif len(mode) == 0: raw_answer = self.device_query(":FREQuency:ARM:START:SOURce?") answer = cutil.search_keys_dictionary(startarm_dic, raw_answer) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(mode) == 1: md = str(mode[0]) if md in startarm_dic: flag = startarm_dic[md] else: assert (1 == 2), "Invalid start arm mode" elif len(mode) == 0: answer = test_gate_start_mode return answer else: assert (1 == 2), "Invalid argument"
def power_supply_range(self, *range): if test_flag != 'test': if len(range) == 1: rng = str(range[0]) if rng in range_dict: flag = range_dict[rng] self.device_write('RNGE ' + str(flag)) else: general.message("Incorrect range") sys.exit() elif len(range) == 0: raw_answer = int(self.device_query('RNGE?')) answer = cutil.search_keys_dictionary(range_dict, raw_answer) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(range) == 1: rng = str(range[0]) assert (rng in range_dict), "Incorrect range" elif len(range) == 0: answer = test_range return answer else: assert (1 == 2), "Invalid argument"
def power_supply_rear_mode(self, *mode): if test_flag != 'test': if len(mode) == 1: md = str(mode[0]) if md in rear_mode_dict: flag = rear_mode_dict[md] self.device_write('SMOD ' + str(flag)) else: general.message('Incorrect rear mode') sys.exit() elif len(mode) == 0: raw_answer = int(self.device_query('SMOD?')) answer = cutil.search_keys_dictionary(rear_mode_dict, raw_answer) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(mode) == 1: md = str(mode[0]) assert (md in rear_mode_dict), "Incorrect rear mode" elif len(mode) == 0: answer = test_rear_mode return answer else: assert (1 == 2), "Invalid argument"
def wave_gen_arbitrary_interpolation(self, *mode, channel = '1'): if test_flag != 'test': ch = channel if ch == '1' or ch == '2': if len(mode) == 1: md = str(mode[0]) if md == 'On': self.device_write(":WGEN" + str(ch) + ":ARBitrary:INTerpolate 1") elif md == 'Off': self.device_write(":WGEN" + str(ch) + ":ARBitrary:INTerpolate 0") else: general.message("Incorrect interpolation control setting is given") sys.exit() elif len(mode) == 0: raw_answer = int(self.device_query(":WGEN"+str(ch)+":ARBitrary:INTerpolate?")) answer = cutil.search_keys_dictionary(wave_gen_interpolation_dictionary, raw_answer) return answer else: general.message("Invalid argument") sys.exit() else: general.message("Incorrect wave generator channel") sys.exit() elif test_flag == 'test': ch = channel assert(ch == '1' or ch == '2'), "Incorrect wave generator channel" if len(mode) == 1: md = str(mode[0]) assert(md == 'On' or md == 'Off'), "Incorrect interpolation control setting is given" elif len(mode) == 0: answer = test_wave_gen_interpolation return answer else: assert(1 == 2), "Invalid argument"
def discrete_io_output_state(self, *state): if test_flag != 'test': if len(state) == 1: st = state[0] if st in output_state_dict: flag = int(output_state_dict[st], 2) self.device_write_unsigned(50, flag, 0) else: general.message("Invalid state") sys.exit() elif len(state) == 0: raw_answer = bin(int(self.device_read_unsigned(50, 0))).replace( "0b", "") answer = cutil.search_keys_dictionary(output_state_dict, raw_answer) return answer elif test_flag == 'test': if len(state) == 1: st = state[0] assert (st in output_state_dict), "Incorrect state" elif len(state) == 0: answer = test_output_state return answer else: assert (1 == 2), "Incorrect argument"
def gaussmeter_units(self, *units): if test_flag != 'test': if len(units) == 1: un = str(units[0]) if un in units_dict: flag = units_dict[un] self.device_write('UNIT ' + str(flag)) else: general.message('Incorrect unit') sys.exit() elif len(units) == 0: raw_answer = int(self.device_query('UNIT?')) answer = cutil.search_keys_dictionary(units_dict, raw_answer) return answer else: general.message('Invalid argument') sys.exit() elif test_flag == 'test': if len(units) == 1: un = str(units[0]) assert (un in units_dict), 'Incorrect unit' elif len(units) == 0: answer = test_unit return answer
def freq_counter_gate_mode(self, *mode): if test_flag != 'test': if len(mode) == 1: md = str(mode[0]) if md in gate_dic: flag = gate_dic[md] self.device_write("FREQuency:GATE:SOURce "+ str(flag)) else: general.message("Invalid gate mode") sys.exit() elif len(mode) == 0: raw_answer = str(self.device_query('FREQuency:GATE:SOURce?')) answer = cutil.search_keys_dictionary(gate_dic, raw_answer) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(mode) == 1: md = str(mode[0]) if md in gate_dic: flag = gate_dic[md] else: assert(1 == 2), "Invalid gate mode" elif len(mode) == 0: answer = test_gate return answer else: assert(1 == 2), "Invalid argument"
def lock_in_ref_slope(self, *mode): if test_flag != 'test': if len(mode) == 1: md = str(mode[0]) if md in ref_slope_dict: flag = ref_slope_dict[md] self.device_write("RTRG "+ str(flag)) else: general.message("Invalid mode") sys.exit() elif len(mode) == 0: raw_answer = int(self.device_query("RTRG?")) answer = cutil.search_keys_dictionary(ref_slope_dict, raw_answer) return answer else: general.message("Invalid argumnet") sys.exit() elif test_flag == 'test': if len(mode) == 1: md = str(mode[0]) if md in ref_slope_dict: pass else: assert(1 == 2), "Incorrect ref slope is used" elif len(mode) == 0: answer = test_ref_slope return answer
def lock_in_sync_filter(self, *mode): if test_flag != 'test': if len(mode) == 1: md = str(mode[0]) if md in sync_dict: flag = sync_dict[md] self.device_write("SYNC "+ str(flag)) else: general.message("Invalid argument") sys.exit() elif len(mode) == 0: raw_answer = int(self.device_query("SYNC?")) answer = cutil.search_keys_dictionary(sync_dict, raw_answer) return answer else: general.message("Invalid argumnet") sys.exit() elif test_flag == 'test': if len(mode) == 1: md = str(mode[0]) if md in sync_dict: pass else: assert(1 == 2), "Incorrect sync filter parameter" elif len(mode) == 0: answer = test_sync return answer
def tc_lock_keyboard(self, *lock): if test_flag != 'test': if len(lock) == 1: lk = str(lock[0]) if lk in lock_dict: flag = lock_dict[lk] self.device_query(str(flag)) else: general.message("Invalid argument") sys.exit() elif len(lock) == 0: raw_answer = self.device_query('X') answer_flag = raw_answer[4:6] answer = cutil.search_keys_dictionary(lock_dict, answer_flag) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(lock) == 1: lk = str(lock[0]) if lk in lock_dict: flag = lock_dict[lk] else: assert (1 == 2), "Invalid lock argument" elif len(lock) == 0: answer = test_lock return answer else: assert (1 == 2), "Invalid argument"
def lock_in_lp_filter(self, *mode): if test_flag != 'test': if len(mode) == 1: md = str(mode[0]) if md in lp_fil_dict: flag = lp_fil_dict[md] self.device_write("OFSL "+ str(flag)) else: general.message("Invalid mode") sys.exit() elif len(mode) == 0: raw_answer = int(self.device_query("OFSL?")) answer = cutil.search_keys_dictionary(lp_fil_dict, raw_answer) return answer else: general.message("Invalid argumnet") sys.exit() elif test_flag == 'test': if len(mode) == 1: md = str(mode[0]) if md in lp_fil_dict: pass else: assert(1 == 2), "Incorrect low pass filter is used" elif len(mode) == 0: answer = test_lp_filter return answer
def lock_in_time_constant(self, *timeconstant): if test_flag != 'test': if len(timeconstant) == 1: temp = timeconstant[0].split(' ') if float(temp[0]) > 30 and temp[1] == 'ks': general.message("Desired sensitivity cannot be set, the nearest available value is used") self.device_write("OFLT "+ str(21)) else: number_tc = min(helper_tc_list, key=lambda x: abs(x - int(temp[0]))) if int(number_tc) == 1000 and temp[1] == 'us': number_tc = 1 temp[1] = 'ms' elif int(number_tc) == 1000 and temp[1] == 'ms': number_tc = 1 temp[1] = 's' elif int(number_tc) == 1000 and temp[1] == 's': number_tc = 1 temp[1] = 'ks' if int(number_tc) != int(temp[0]): general.message("Desired time constant cannot be set, the nearest available value is used") tc = str(number_tc) + ' ' + temp[1] if tc in timeconstant_dict: flag = timeconstant_dict[tc] self.device_write("OFLT "+ str(flag)) else: general.message("Invalid time constant value (too high/too low)") sys.exit() elif len(timeconstant) == 0: raw_answer = int(self.device_query("OFLT?")) answer = cutil.search_keys_dictionary(timeconstant_dict, raw_answer) return answer else: general.message("Invalid Argument") sys.exit() elif test_flag == 'test': if len(timeconstant) == 1: temp = timeconstant[0].split(' ') if float(temp[0]) > 30 and temp[1] == 'ks': tc = '30 ks' else: number_tc = min(helper_tc_list, key=lambda x: abs(x - int(temp[0]))) if int(number_tc) == 1000 and temp[1] == 'us': number_tc = 1 temp[1] = 'ms' elif int(number_tc) == 1000 and temp[1] == 'ms': number_tc = 1 temp[1] = 's' elif int(number_tc) == 1000 and temp[1] == 's': number_tc = 1 temp[1] = 'ks' tc = str(number_tc) + ' ' + temp[1] if tc in timeconstant_dict: pass else: assert(1 == 2), "Incorrect time constant is used" elif len(timeconstant) == 0: answer = test_timeconstant return answer
def lock_in_sensitivity(self, *sensitivity): if test_flag != 'test': if len(sensitivity) == 1: temp = sensitivity[0].split(' ') if float(temp[0]) > 1 and temp[1] == 'V': general.message("Desired sensitivity cannot be set, the nearest available value is used") self.device_write("SCAL "+ str(0)) else: number_sens = min(helper_sens_list, key=lambda x: abs(x - int(temp[0]))) if int(number_sens) == 1000 and temp[1] == 'nV': number_sens = 1 temp[1] = 'uV' elif int(number_sens) == 1000 and temp[1] == 'uV': number_sens = 1 temp[1] = 'mV' elif int(number_sens) == 1000 and temp[1] == 'mV': number_sens = 1 temp[1] = 'V' sens = str(number_sens) + ' ' + temp[1] if int(number_sens) != int(temp[0]): general.message("Desired sensitivity cannot be set, the nearest available value is used") if sens in sensitivity_dict: flag = sensitivity_dict[sens] self.device_write("SCAL "+ str(flag)) else: general.message("Invalid sensitivity value (too high/too low)") sys.exit() elif len(sensitivity) == 0: raw_answer = int(self.device_query("SCAL?")) answer = cutil.search_keys_dictionary(sensitivity_dict, raw_answer) return answer else: general.message("Invalid Argument") sys.exit() elif test_flag == 'test': if len(sensitivity) == 1: temp = sensitivity[0].split(' ') if float(temp[0]) > 1 and temp[1] == 'V': sens = '1 V' else: number_sens = min(helper_sens_list, key=lambda x: abs(x - int(temp[0]))) if int(number_sens) == 1000 and temp[1] == 'nV': number_sens = 1 temp[1] = 'uV' elif int(number_sens) == 1000 and temp[1] == 'uV': number_sens = 1 temp[1] = 'mV' elif int(number_sens) == 1000 and temp[1] == 'mV': number_sens = 1 temp[1] = 'V' tc = str(number_sens) + ' ' + temp[1] if tc in sensitivity_dict: pass else: assert(1 == 2), "Incorrect sensitivity is used" elif len(sensitivity) == 0: answer = test_sensitivity return answer
def power_supply_channel_state(self, *state): if test_flag != 'test': if len(state) == 2: ch = str(state[0]) st = str(state[1]) if ch in channel_dict: flag = channel_dict[ch] if flag <= channels: if st in state_dict: self.device_write(':OUTPut CH' + str(flag) + ',' + str(state_dict[st])) else: general.message("Invalid state argument") sys.exit() else: general.message("Invalid channel") sys.exit() else: general.message("Invalid channel") sys.exit() elif len(state) == 1: ch = str(state[0]) if ch in channel_dict: flag = channel_dict[ch] if flag <= channels: raw_answer = self.device_query(':OUTPut? CH' + str(flag)) answer = cutil.search_keys_dictionary( state_dict, raw_answer) return answer else: general.message("Invalid channel") sys.exit() else: general.message("Invalid channel") sys.exit() else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(state) == 2: ch = str(state[0]) st = str(state[1]) assert (ch in channel_dict), 'Invalid channel argument' flag = channel_dict[ch] assert (flag <= channels), "Invalid channel" assert (st in state_dict), 'Invalid state argument' elif len(state) == 1: ch = str(state[0]) assert (ch in channel_dict), 'Invalid channel argument' flag = channel_dict[ch] assert (flag <= channels), "Invalid channel" answer = test_state return answer
def discrete_io_input_state(self): if test_flag != 'test': raw_answer = bin(int(self.device_read_unsigned(51, 0))).replace( "0b", "") answer = cutil.search_keys_dictionary(input_state_dict, raw_answer) return answer elif test_flag == 'test': answer = test_input_state return answer
def power_supply_interlock(self, *interlock): if test_flag != 'test': if len(interlock) == 0: raw_answer = int(self.device_query('ILOC?')) answer = cutil.search_keys_dictionary(lock_dict, raw_answer) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(interlock) == 0: answer = test_lock return answer else: assert (1 == 2), "Invalid argument"
def delay_gen_output_polarity(self, *polarity): if test_flag != 'test': if len(polarity) == 2: ch = str(polarity[0]) plr = str(polarity[1]) if ch in output_channel_dict: flag_1 = output_channel_dict[ch] if plr in polarity_dict: flag_2 = polarity_dict[plr] if int(self.device_query('OM ' + str(flag_1))) != 3: general.wait('30 ms') self.device_write('OP ' + str(flag_1) + ',' + str(flag_2)) else: general.message("You are in Variable mode") else: general.message("Incorrect polarity") sys.exit() else: general.message("Invalid channel") sys.exit() elif len(polarity) == 1: ch = str(polarity[0]) if ch in output_channel_dict: flag = output_channel_dict[ch] raw_answer = int(self.device_query('OP ' + str(flag))) answer = cutil.search_keys_dictionary(polarity_dict, raw_answer) return answer else: general.message("Invalid channel") sys.exit() else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(polarity) == 2: ch = str(polarity[0]) plr = str(polarity[1]) assert(ch in output_channel_dict), 'Invalid channel argument' assert(plr in polarity_dict), 'Invalid polarity argument' elif len(polarity) == 1: ch = str(polarity[0]) assert(ch in output_channel_dict), 'Invalid channel argument' answer = test_polarity return answer
def delay_gen_output_mode(self, *mode): if test_flag != 'test': if len(mode) == 2: ch = str(mode[0]) md = str(mode[1]) if ch in output_channel_dict: flag_1 = output_channel_dict[ch] if md in mode_dict: flag_2 = mode_dict[md] self.device_write('OM ' + str(flag_1) + ',' + str(flag_2)) else: general.message("Incorrect mode") sys.exit() else: general.message("Invalid channel") sys.exit() elif len(mode) == 1: ch = str(mode[0]) if ch in output_channel_dict: flag = output_channel_dict[ch] raw_answer = int(self.device_query('OM ' + str(flag))) answer = cutil.search_keys_dictionary(mode_dict, raw_answer) return answer else: general.message("Invalid channel") sys.exit() else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(mode) == 2: ch = str(mode[0]) md = str(mode[1]) assert(ch in output_channel_dict), 'Invalid channel argument' assert(md in mode_dict), 'Invalid mode argument' elif len(mode) == 1: ch = str(mode[0]) assert(ch in output_channel_dict), 'Invalid channel argument' answer = test_mode return answer
def delay_gen_impedance(self, *impedance): if test_flag != 'test': if len(impedance) == 2: ch = str(impedance[0]) imp = str(impedance[1]) if ch in input_output_channel_dict: flag_1 = input_output_channel_dict[ch] if imp in impedance_dict: flag_2 = impedance_dict[imp] self.device_write('TZ ' + str(flag_1) + ',' + str(flag_2)) else: general.message("Incorrect impedance") sys.exit() else: general.message("Invalid channel") sys.exit() elif len(impedance) == 1: ch = str(impedance[0]) if ch in input_output_channel_dict: flag = input_output_channel_dict[ch] raw_answer = int(self.device_query('TZ ' + str(flag))) answer = cutil.search_keys_dictionary(impedance_dict, raw_answer) return answer else: general.message("Invalid channel") sys.exit() else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(impedance) == 2: ch = str(impedance[0]) imp = str(impedance[1]) assert(ch in input_output_channel_dict), 'Invalid channel argument' assert(imp in impedance_dict), 'Invalid impedance argument' elif len(impedance) == 1: ch = str(impedance[0]) assert(ch in input_output_channel_dict), 'Invalid channel argument' answer = test_impedance return answer
def tc_state(self, *mode): if test_flag != 'test': if len(mode) == 1: md = str(mode[0]) if md in state_dict: flag = state_dict[md] if flag == 2 or flag == 3: raw_answer = self.device_query('X') answer = raw_answer[2:4] if answer == 'A5' or answer == 'A6' or answer == 'A7' or answer == 'A8': general.message( 'Cannot set state to GAS AUTO while in AutoGFS phase.' ) else: self.device_query("A" + str(flag)) else: self.device_query("A" + str(flag)) else: general.message("Invalid temperature controller state") sys.exit() elif len(mode) == 0: raw_answer = self.device_query('X') answer_flag = int(raw_answer[3:4]) answer = cutil.search_keys_dictionary(state_dict, answer_flag) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(mode) == 1: md = str(mode[0]) if md in state_dict: flag = state_dict[md] else: assert (1 == 2), "Invalid heater range" elif len(mode) == 0: answer = test_mode return answer else: assert (1 == 2), "Invalid heater range"
def tc_heater_range(self, *heater): if test_flag != 'test': if len(heater) == 1: hr = str(heater[0]) if hr in heater_dict: flag = heater_dict[hr] if int(loop_config) in loop_list: self.device_write("RANGE " + str(loop_config) + ',' + str(flag)) else: general.message('Invalid loop') sys.exit() else: general.message("Invalid heater range") sys.exit() elif len(heater) == 0: raw_answer = int( self.device_query("RANGE? " + str(loop_config))) answer = cutil.search_keys_dictionary(heater_dict, raw_answer) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(heater) == 1: hr = str(heater[0]) if hr in heater_dict: flag = heater_dict[hr] assert (int(loop_config) in loop_list), 'Invalid loop argument' else: assert (1 == 2), "Invalid heater range" elif len(heater) == 0: answer = test_heater_range return answer else: assert (1 == 2), "Invalid heater range"
def tc_sensor(self, *sensor): if test_flag != 'test': if len(sensor) == 2: sens = str(sensor[0]) state = str(sensor[1]) if state in state_dict: flag = state_dict[state] else: general.message('Incorrect state') sys.exit() if sens in channel_dict: if sens == '1': self.device_write_unsigned(384, flag, 0) elif sens == '2': self.device_write_unsigned(1408, flag, 0) elif sens == '3': self.device_write_unsigned(2432, flag, 0) elif sens == '4': self.device_write_unsigned(3456, flag, 0) else: general.message('Incorrect loop') sys.exit() elif len(sensor) == 1: sens = str(sensor[0]) if sens in channel_dict: if sens == '1': raw_answer = int(self.device_read_unsigned(384, 0)) answer = cutil.search_keys_dictionary( state_dict, raw_answer) return answer elif sens == '2': raw_answer = int(self.device_read_unsigned(1408, 0)) answer = cutil.search_keys_dictionary( state_dict, raw_answer) return answer elif sens == '3': raw_answer = int(self.device_read_unsigned(2432, 0)) answer = cutil.search_keys_dictionary( state_dict, raw_answer) return answer elif sens == '4': raw_answer = int(self.device_read_unsigned(3456, 0)) answer = cutil.search_keys_dictionary( state_dict, raw_answer) return answer else: general.message('Incorrect loop') sys.exit() else: general.message('Invalid argument') sys.exit() elif test_flag == 'test': if len(sensor) == 2: sens = str(sensor[0]) state = str(sensor[1]) assert (sens in channel_dict), 'Invalid loop' assert (state in state_dict), 'Invalid state' elif len(sensor) == 1: sens = str(sensor[0]) assert (sens in channel_dict), 'Invalid loop' answer = test_loop_state return answer
def tc_lock_keyboard(self, *lock): if test_flag != 'test': if len(lock) == 1: lk = str(lock[0]) if lk in lock_dict: flag = lock_dict[lk] if flag == 0: self.device_write('LOCK 1,123') self.device_write('MODE 1') elif flag == 1: self.device_write('LOCK 1,123') self.device_write('MODE 2') elif flag == 2: self.device_write('LOCK 0,123') self.device_write('MODE 1') elif flag == 3: self.device_write('LOCK 0,123') self.device_write('MODE 2') else: general.message("Invalid argument") sys.exit() elif len(lock) == 0: raw_answer1 = self.device_query('LOCK?') if config['interface'] == 'gpib': answer1 = int(raw_answer1.decode()[0]) elif config['interface'] == 'rs232': answer1 = int(raw_answer1[0]) answer2 = int(self.device_query('MODE?')) if answer1 == 1 and answer2 == 1: answer_flag = 0 answer = cutil.search_keys_dictionary( lock_dict, answer_flag) return answer elif answer1 == 1 and answer2 == 2: answer_flag = 1 answer = cutil.search_keys_dictionary( lock_dict, answer_flag) return answer elif answer1 == 0 and answer2 == 1: answer_flag = 2 answer = cutil.search_keys_dictionary( lock_dict, answer_flag) return answer elif answer1 == 0 and answer2 == 2: answer_flag = 3 answer = cutil.search_keys_dictionary( lock_dict, answer_flag) return answer else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(lock) == 1: lk = str(lock[0]) if lk in lock_dict: flag = lock_dict[lk] else: assert (1 == 2), "Invalid lock argument" elif len(lock) == 0: answer = test_lock return answer else: assert (1 == 2), "Invalid argument"
def power_supply_channel_state(self, *state): if test_flag != 'test': if len(state) == 2: ch = str(state[0]) st = str(state[1]) if ch in channel_dict: flag = channel_dict[ch] if flag <= channels: if st in state_dict: rng = int(self.device_query('RNGE?')) general.wait('20 ms') iloc = int(self.device_query('ILOC?')) if iloc != 1 and rng == 2: general.message('Safety interlock is open') sys.exit() else: self.device_write('SOUT ' + str(flag)) else: general.message("Invalid state argument") sys.exit() else: general.message("Invalid channel") sys.exit() else: general.message("Invalid channel") sys.exit() elif len(state) == 1: ch = str(state[0]) if ch in channel_dict: flag = channel_dict[ch] if flag <= channels: raw_answer = int(self.device_query('SOUT?')) answer = cutil.search_keys_dictionary( state_dict, raw_answer) return answer else: general.message("Invalid channel") sys.exit() else: general.message("Invalid channel") sys.exit() else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(state) == 2: ch = str(state[0]) st = str(state[1]) assert (ch in channel_dict), 'Invalid channel argument' flag = channel_dict[ch] assert (flag <= channels), "Invalid channel" assert (st in state_dict), 'Invalid state argument' elif len(state) == 1: ch = str(state[0]) assert (ch in channel_dict), 'Invalid channel argument' flag = channel_dict[ch] assert (flag <= channels), "Invalid channel" answer = test_state return answer
def delay_gen_delay(self, *delay): if test_flag != 'test': if len(delay) == 3: ch_1 = str(delay[0]) ch_2 = str(delay[1]) temp = delay[2].split(" ") delay = float(temp[0]) scaling = temp[1] if (ch_1 in delay_channel_dict) and (ch_2 in delay_channel_dict): flag_1 = delay_channel_dict[ch_1] flag_2 = delay_channel_dict[ch_2] if scaling in time_dict: coef = time_dict[scaling] if delay/coef >= delay_min and delay/coef <= delay_max: self.device_write('DT ' + str(flag_1) + ',' + str(flag_2) + ',' + str(delay/coef)) else: general.message("Incorrect delay range") sys.exit() else: general.message("Incorrect delay scaling") sys.exit() else: general.message("Incorrect channel") sys.exit() elif len(delay) == 1: ch_1 = str(delay[0]) if (ch_1 in delay_channel_dict): flag_1 = delay_channel_dict[ch_1] raw_answer = str(self.device_query('DT ' + str(flag_1))).split(',') ch_answer = cutil.search_keys_dictionary(delay_channel_dict, int(raw_answer[0])) delay_answer = float(raw_answer[1])*1000000 answer = str(ch_answer) + ' + ' + str(delay_answer) return answer else: general.message("Incorrect channel") sys.exit() else: general.message("Invalid argument") sys.exit() elif test_flag == 'test': if len(delay) == 3: ch_1 = str(delay[0]) ch_2 = str(delay[1]) temp = delay[2].split(" ") delay = float(temp[0]) scaling = temp[1] assert(ch_1 in delay_channel_dict), 'Invalid channel_1 argument' assert(ch_2 in delay_channel_dict), 'Invalid channel_2 argument' assert(scaling in time_dict), 'Invalid scaling argument' coef = time_dict[scaling] assert(delay/coef >= delay_min and delay/coef <= delay_max), "Incorrect delay range" elif len(delay) == 1: ch_1 = str(delay[0]) assert(ch_1 in delay_channel_dict), 'Incorrect channel' answer = test_delay return answer else: assert(1 == 2), 'Invalid argument'