def save(self): self.dataset.clear() log_to_screen(DEBUG) save_params = self.save_Settings.widget.get() t = save_params['sleep time'] file_name = save_params['name'] chnl = 1 time_0 = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds while (1): power = self.vna.marker_Y[chnl].magnitude time_now = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds delta_time = time_now - time_0 with open( 'D:/MW data/test/20190923/JTWPA/scan_1/save/{}.txt'.format( file_name), 'a') as file: write_str = '%f %f\n' % (power, delta_time) file.write(write_str) self.vna.save_csv( 'D:/MW data/test/20190923/JTWPA/scan_1/save/{}.csv'.format( delta_time)) #self.vna.save_csv_second('D:/MW data/test/20190813/JTWPA/scan_1/phase/{}.csv'.format(delta_time)) time.sleep(t) return
def marker(self): self.dataset.clear() log_to_screen(DEBUG) marker_params = self.Analyzer_Marker_Settings.widget.get() chnl = marker_params['channel'] stat = marker_params['state'] self.analyzer.marker[chnl]=stat
def set_vna_marker(self): self.dataset.clear() log_to_screen(DEBUG) vna_marker_params = self.VNA_Marker_Settings.widget.get() chnl = vna_marker_params['channel'] stat = vna_marker_params['state'] self.vna.marker[chnl] = stat
def up_0(self, value): self.dataset.clear() log_to_screen(DEBUG) offset = value * Hz frequency_start = 5122.612 * MHz frequency_stop = 5122.612 * MHz + offset frequency_step = offset / 100 self.source.output = 1 self.source.power = 9 self.source.Trigger_Setting = 9 self.source.Ext_FM_Type = 1 self.source.Ext_FM_Deviation = 200000 * Hz self.source.frequency = frequency_start time.sleep(5) with open('D:/MW data/test/20190909/offset/1/{}.txt'.format(value), 'a') as file: write_str = '%f %f %f %f %f\n' % (0, 0, 0, 0, 0) file.write(write_str) while (self.source.frequency < frequency_stop): buffer_D = self.lockin.Data_Four part = buffer_D.split(',') XValue = part[0] YValue = part[1] RValue = part[2] thetaValue = part[3] with open('D:/MW data/test/20190909/offset/1/{}.txt'.format(value), 'a') as file: write_str = '%s %s %s %s %f\n' % ( part[0], part[1], part[2], part[3], self.source.frequency.magnitude) file.write(write_str) a = np.loadtxt( 'D:/MW data/test/20190909/offset/1/{}.txt'.format(value)) self.X_s = a[1:, 0] self.Y_s = a[1:, 1] self.R_s = a[1:, 2] self.theta_s = a[1:, 3] self.time_s = a[1:, 4] values = { 't': self.time_s, 'Y': self.Y_s, 'R': self.R_s, 'X': self.X_s, 'theta': self.theta_s, } self.Record_data_time.acquire(values) self.source.frequency = self.source.frequency + frequency_step return
def set(self): self.dataset.clear() log_to_screen(DEBUG) freq_params = self.Frequency_Settings.widget.get() # amp_params = self.Frequency_Settings.widget.get() span = freq_params['frequency span'] center = freq_params['center freq'] self.spa.freq_span = span self.spa.freq_cent = center
def set_analyzer_amp(self): self.dataset.clear() log_to_screen(DEBUG) analyzer_amp_params = self.Analyzer_Amplitude_Settings.widget.get() ref = analyzer_amp_params['ref level'] scale = analyzer_amp_params['scale'] self.analyzer.ref_level = ref*dBm self.analyzer.Y_scale = scale*dBm
def noise(self, value): self.dataset.clear() log_to_screen(DEBUG) frequency_center = 5104.1 * MHz self.source.output = 1 self.source.Trigger_Setting = 9 self.source.Ext_FM_Type = 1 self.source.Ext_FM_Deviation = 180000 * Hz self.lockin.Internal_Frequency = value * Hz self.source.frequency = frequency_center time.sleep(5) t = 0 with open('D:/MW data/test/20190907/noise/1/{}.txt'.format(value), 'a') as file: write_str = '%f %f %f %f %f\n' % (0, 0, 0, 0, 0) file.write(write_str) while (t < 600): buffer_D = self.lockin.Data_Four part = buffer_D.split(',') XValue = part[0] YValue = part[1] RValue = part[2] thetaValue = part[3] with open('D:/MW data/test/20190907/noise/1/{}.txt'.format(value), 'a') as file: write_str = '%s %s %s %s %f\n' % (part[0], part[1], part[2], part[3], t) file.write(write_str) a = np.loadtxt( 'D:/MW data/test/20190907/noise/1/{}.txt'.format(value)) self.X_s = a[1:, 0] self.Y_s = a[1:, 1] self.R_s = a[1:, 2] self.theta_s = a[1:, 3] self.time_s = a[1:, 4] values = { 't': self.time_s, 'Y': self.Y_s, 'R': self.R_s, 'X': self.X_s, 'theta': self.theta_s, } self.Record_data_time.acquire(values) time.sleep(0.1) t = t + 0.2 return
def set_source_stb(self): self.dataset.clear() log_to_screen(DEBUG) source_stb_params = self.Source_Stability_Settings.widget.get() pll = source_stb_params['pll pump current'] spc = source_stb_params['channel spacing'] self.source.PLL_charge_pump_current=pll self.source.channel_spacing=spc
def set_vna_freq(self): self.dataset.clear() log_to_screen(DEBUG) vna_freq_params = self.VNA_Frequency_Settings.widget.get() span = vna_freq_params['frequency span'] center = vna_freq_params['center freq'] self.vna.freq_span = span self.vna.freq_cent = center
def save(self): self.dataset.clear() log_to_screen(DEBUG) save_params = self.Save_Settings.widget.get() t = save_params['sleep time'] count = save_params['file count'] for x in range(count): self.spa.savefile(x) time.sleep(t)
def set_freq(self): self.dataset.clear() log_to_screen(DEBUG) freq_params = self.Source_Frequency_Settings.widget.get() key = freq_params['output state'] freq = freq_params['frequency'] self.source.output = key self.source.frequency = freq print('Setting source done!')
def set_freq(self): self.dataset.clear() log_to_screen(DEBUG) freq_params = self.Analyzer_Frequency_Settings.widget.get() span = freq_params['frequency span'] center = freq_params['center freq'] self.analyzer.freq_span = span self.analyzer.freq_cent = center print('Setting frequency done!')
def sweep_frequency(self): self.dataset.clear() log_to_screen(DEBUG) sweep_frequency_params = self.Sweep_frequency_Settings.widget.get() mk_freq = sweep_frequency_params['marker frequency'] fr_low = sweep_frequency_params['start frequency'] fr_high = sweep_frequency_params['stop frequency'] fr_stp = sweep_frequency_params['step'] t_stp = sweep_frequency_params['step time'] pw = sweep_frequency_params['sweep power'] name = sweep_frequency_params['txt name'] t = sweep_frequency_params['sleep time'] chnl = sweep_frequency_params['marker channel'] self.vna.marker[chnl] = 'ON' self.vna.marker_X[chnl] = mk_freq self.source.sweep_lower = fr_low self.source.sweep_upper = fr_high self.source.sweep_size = fr_stp self.source.sweep_step_time = t_stp self.source.power = pw self.source.sweep_power_high = pw self.source.sweep_power_low = pw self.source.sweep_run = 0 time.sleep(5) self.source.output = 1 self.source.sweep_run = 1 time_0 = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds while (int(self.source.sweep_run) != 0): power = self.vna.marker_Y[chnl].magnitude frequency = self.source.frequency.magnitude time_now = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds delta_time = time_now - time_0 self.freqs.append(frequency) self.powers.append(power) with open( 'D:/MW data/test/20191008/JTWPA/frequency sweep/scan_5/{}.txt' .format(name), 'a') as file: write_str = '%f %f\n' % (frequency, power) file.write(write_str) self.vna.save_csv('D:/20191008/{}.csv'.format(delta_time)) #self.vna.save_csv_second('D:/MW data/test/20190813/JTWPA/scan_1/phase/{}.csv'.format(delta_time)) time.sleep(t) return
def set(self): self.dataset.clear() log_to_screen(DEBUG) freq_params = self.Frequency_Settings.widget.get() # amp_params = self.Frequency_Settings.widget.get() span = freq_params['frequency span'] center = freq_params['center freq'] # ref = amp_params['ref level'] self.spa.freq_span = span self.spa.freq_cent = center # self.spa.ref_level = ref #self.spa.freq_star = start print('set frequency span to {}'.format(span)) print('set center frequency to {}'.format(center))
def sweep_power_frequency(self): self.dataset.clear() log_to_screen(DEBUG) sweep_pw_fr_params = self.Sweep_Power_and_Frequency_Settings.widget.get( ) mk_freq = sweep_pw_fr_params['marker frequency'] p_low = sweep_pw_fr_params['start power'] p_high = sweep_pw_fr_params['stop power'] p_stp = sweep_pw_fr_params['step power'] fr_low = sweep_pw_fr_params['start frequency'] fr_high = sweep_pw_fr_params['stop frequency'] fr_stp = sweep_pw_fr_params['step frequency'] stp_t = sweep_pw_fr_params['step time'] name = sweep_pw_fr_params['txt name'] t = sweep_pw_fr_params['sleep time'] chnl = sweep_pw_fr_params['marker channel'] self.vna.marker[chnl] = 'ON' self.vna.marker_X[chnl] = mk_freq self.source.sweep_lower = fr_low self.source.sweep_upper = fr_high self.source.sweep_size = fr_stp self.source.sweep_step_time = stp_t self.source.Trigger_Setting = 0 self.source.output = 1 pw_count = (p_high - p_low) / p_stp self.source.sweep_run = 0 time.sleep(5) for pw_point in range(int(pw_count)): pw_current_value = p_low + pw_point * p_stp self.source.sweep_power_low = pw_current_value self.source.sweep_power_high = pw_current_value self.source.sweep_run = 1 while (int(self.source.sweep_run) != 0): #self.vna.marker_peak_search[chnl] S = self.vna.marker_Y[chnl].magnitude frequency = self.source.frequency.magnitude power = float(self.source.power) with open( 'D:/MW data/test/20191008/JTWPA/scan_1/freq and pw/{}.txt' .format(name), 'a') as file: write_str = '%f %f %f\n' % (frequency, power, S) file.write(write_str) time.sleep(t) return
def set_source_freq(self): self.dataset.clear() log_to_screen(DEBUG) source_freq_params = self.Source_Frequency_Settings.widget.get() stat = source_freq_params['output state'] pw = source_freq_params['power'] freq = source_freq_params['frequency'] run = source_freq_params['sweep state'] self.source.output=stat self.source.frequency=freq self.source.power = pw self.source.sweep_run = run print('Setting frequency done!')
def main(): import logging import sys from lantz.log import log_to_screen log_to_screen(logging.CRITICAL) res_name = sys.argv[1] with BK9129b(res_name) as inst: print(inst.idn) inst.remote() inst.channel = 2 print(inst.channel) print(inst.current[1]) print(inst.voltage[1]) inst.state = True print(inst.state) inst.voltage_limit = 1.23 print(inst.voltage_limit)
def sweep_power(self): self.dataset.clear() log_to_screen(DEBUG) sweep_pw_params = self.Sweep_power_Settings.widget.get() freq = sweep_pw_params['sweep frequency'] mk_freq = sweep_pw_params['marker frequency'] pw_low = sweep_pw_params['start power'] pw_high = sweep_pw_params['stop power'] pw_stp = sweep_pw_params['step power'] name = sweep_pw_params['txt name'] t = sweep_pw_params['sleep time'] chnl = sweep_pw_params['marker channel'] self.vna.marker[chnl] = 'ON' self.vna.marker_X[chnl] = mk_freq self.source.frequency = freq self.source.output = 1 self.source.Trigger_Setting = 0 time_0 = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds pw_count = int((pw_high - pw_low) / pw_stp) for p in range(0, pw_count): self.source.power = pw_low + p * pw_stp amplitude = self.vna.marker_Y[chnl].magnitude frequency = self.source.frequency.magnitude time_now = self.vna.day * 3600 * 24 + self.vna.hours * 3600 + self.vna.minutes * 60 + self.vna.seconds delta_time = time_now - time_0 with open( 'D:/MW data/test/20191008/JTWPA/power sweep/scan4/{}.txt'. format(name), 'a') as file: write_str = '%f %f %s\n' % (frequency, amplitude, self.source.power) file.write(write_str) self.vna.save_csv('D:/20191008/{}.csv'.format(delta_time)) #self.vna.save_csv_second('D:/MW data/test/20190813/JTWPA/scan_1/phase/{}.csv'.format(delta_time)) time.sleep(t) return
def main(): import logging import sys from lantz.log import log_to_screen log_to_screen(logging.CRITICAL) res_name = sys.argv[1] fmt_str = "{:<20}|{:>20}" axis = 1 with Agilis(res_name) as inst: inst.channel = 1 print(fmt_str.format("Device version", inst.version)) print(fmt_str.format("Current channel", inst.channel)) amplitudes = inst.step_amplitude[axis] print(fmt_str.format("- Step amplitude", amplitudes[0])) print(fmt_str.format("+ Step amplitude", amplitudes[1])) print(inst.calibrate(1)) print(inst.calibrate(2)) inst.channel = 2 print(inst.calibrate(1)) print(inst.calibrate(2))
def sweep_frequency(self): self.dataset.clear() log_to_screen(DEBUG) sweep_frequency_params = self.Sweep_frequency_Settings.widget.get() chnl = sweep_frequency_params['marker channel'] mk_freq = sweep_frequency_params['marker frequency'] fr_low = sweep_frequency_params['start frequency'] fr_high = sweep_frequency_params['stop frequency'] fr_stp = sweep_frequency_params['step'] t_stp = sweep_frequency_params['step time'] pw = sweep_frequency_params['sweep power'] name = sweep_frequency_params['txt name'] self.vna.marker[chnl] = 'ON' self.vna.marker_X[chnl] = mk_freq self.source.sweep_lower=fr_low self.source.sweep_upper=fr_high self.source.sweep_size=fr_stp self.source.sweep_step_time=t_stp self.source.power=pw self.source.output=1 self.source.sweep_run=1 while(int(self.source.sweep_run)!=0): power=self.vna.marker_Y[chnl].magnitude frequency=self.source.frequency.magnitude self.freqs.append(frequency) self.powers.append(power) values = { 'x': np.asarray(self.freqs), 'y': np.asarray(self.powers), } self.startpulse.acquire(values) # with open('D:/MW data/test/20190808/frequency sweep/{}.txt'.format(name),'a') as file: # write_str='%f %f\n'%(frequency,power) # file.write(write_str) return
def set(self): self.dataset.clear() log_to_screen(DEBUG) freq_params = self.Frequency_Settings.widget.get() # amp_params = self.Frequency_Settings.widget.get() span = freq_params['frequency span'] center = freq_params['center freq'] # ref = amp_params['ref level'] # span=3000000 # center=5000000 self.spa.freq_span = span self.spa.freq_cent = center # self.spa.ref_level = ref # self.spa.freq_star = start # span=1e6 # self.spa.freq_span = span # freqstart=4e9+span/2 # freqstop=7e9-span/2 # nstep=(freqstop-freqstart)/span+1 # print("number of steps are {}".format(nstep)) # print('the loop') # for x in range(0,3000): # try: # self.spa.freq_cent = freqstart+x*span # except: # print('failed') # Need to figure out why doesn't the for loop work with number as arguments # print('set frequency span to {}'.format(span)) # print('set center frequency to {}'.format(center)) print('done!') for x in range(1, 20): self.spa.savefile(x) time.sleep(30)
def main(): import logging import sys from lantz.log import log_to_screen log_to_screen(logging.CRITICAL) res_name = sys.argv[1] with XPSQ8(res_name) as inst: value = inst._xps.GroupJogParametersGet(inst._socket_id, 'Group1.Pos', 1) ret = inst._xps.GroupJogParametersSet(inst._socket_id, 'Group2.Pos', [ -0.0, ], [ 1.0, ]) print(ret) value = inst._xps.GroupJogParametersGet(inst._socket_id, 'Group2.Pos', 1) print(value) return positions = np.linspace(-12.5, 12.5, 20) for val in positions: print(val) inst.abs_position['Group1.Pos'] = val print(inst.abs_position['Group1.Pos'])
@Feat def voltage(self): return self.query('VSET1?') def set_voltage(self, value): self.write('VSET1:{}'.format(value)) def set_output(self, value): self.write('OUT{}'.format(value)) if __name__ == '__main__': from time import sleep from lantz import Q_ from lantz.log import log_to_screen, DEBUG log_to_screen(DEBUG) with GPD3303S('ASRL22::INSTR') as inst: print('The identification of this instrument is:' + inst.idn) print('The voltage of this instrument is:' + inst.voltage) inst.set_voltage(12) print('The voltage of this instrument is:' + inst.voltage) inst.set_output(1) sleep(2) inst.set_output(0)
def initialize(self): log_to_screen(DEBUG) print('initializing move...') self.attocube = ANC350() self.attocube.initialize() return
parser = argparse.ArgumentParser() parser.add_argument('--debug', help='Send debug output to screen', action='store_true') args = parser.parse_args() from lantz.log import LOGGER, DEBUG LOGGER.setLevel(DEBUG) import logging fh = logging.FileHandler('esp300.log', mode='w') formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') fh.setFormatter(formatter) fh.setLevel(DEBUG) LOGGER.addHandler(fh) if args.debug: from lantz.log import log_to_screen log_to_screen(DEBUG) from lantz import Q_ from time import sleep with ESP300('GPIB0::3::INSTR') as inst: for axis in inst.axes: print('Axis {:d}'.format(axis)) print('ID: ' + inst.ID[axis]) print('Position: {:f}'.format(inst.position[axis])) print('Target Position: {:f}'.format(inst.target_position[axis])) print('Velocity: {:f}'.format(inst.velocity[axis])) print('Target Velocity: {:f}'.format(inst.target_velocity[axis])) print('Position: {:f}'.format(inst.position[1])) print('Moving 1um') inst.maximum_velocity[1] = Q_(400,'um/s') inst.target_velocity[1] = Q_(200,'um/s')
# 1. LD OFF self.ld_state = 0 # 2. Wait while (abs(self.ld_current.m) > current_error.m): pass # 1. TEC OFF self.tec_state = 0 if __name__ == '__main__': import logging import sys from lantz.log import log_to_screen log_to_screen(logging.CRITICAL) #res_name = sys.argv[1] res_names = [ 'USB0::0x1313::0x804F::SERIALNUMBER::INSTR', 'USB0::0x1313::0x804F::SERIALNUMBER::INSTR' ] print('update res_names!') fmt_str = "{:<30}|{:>30}" on_time = 20 for resource in res_names: with CLD101XLP(resource) as inst:
def Record_data_time(self): self.dataset.clear() log_to_screen(DEBUG) record_cavity_params = self.Record_cavity_Settings.widget.get() f_cent = record_cavity_params['center frequency'] f_span = record_cavity_params['span'] t = record_cavity_params['sleep time in second'] stop = record_cavity_params['stop time in second'] name = record_cavity_params['txt name'] v_chnl = 1 l_chnl = 2 r_chnl = 3 time_0 = self.vna.day*3600*24+self.vna.hours*3600+self.vna.minutes*60+self.vna.seconds #while(self.vna.day*3600*24+self.vna.hours*3600+self.vna.minutes*60+self.vna.seconds-time_0 <= stop): while(1): # self.vna.freq_cent = f_cent # self.vna.freq_span = f_span self.vna.auto_scale() self.vna.auto_scale_second() self.vna.marker[v_chnl] = 'ON' self.vna.marker[l_chnl] = 'ON' self.vna.marker[r_chnl] = 'ON' self.vna.marker_second[v_chnl] = 'ON' self.vna.marker_second[l_chnl] = 'ON' self.vna.marker_second[r_chnl] = 'ON' self.vna.marker_peak_search[v_chnl] max_value = self.vna.marker_Y[v_chnl] A_0 = self.vna.marker_Y[v_chnl].magnitude self.vna.marker_min_search[v_chnl] min_value = self.vna.marker_Y[v_chnl] A_1 = self.vna.marker_Y[v_chnl].magnitude target = (max_value + min_value)/2 A = A_0 - A_1 portion = 10**((A_1 - A_0)/20) self.vna.target_value[l_chnl] = target self.vna.target_value[r_chnl] = target self.vna.marker_min_search[l_chnl] self.vna.marker_target_left_search[l_chnl] self.vna.marker_min_search[r_chnl] self.vna.marker_target_right_search[r_chnl] half = self.vna.marker_X[r_chnl].magnitude - self.vna.marker_X[l_chnl].magnitude larger = (portion*half + half)/2 smaller = half - larger time_now = self.vna.day*3600*24+self.vna.hours*3600+self.vna.minutes*60+self.vna.seconds delta_time = time_now-time_0 power = self.vna.marker_Y[v_chnl].magnitude frequency = self.vna.marker_X[v_chnl].magnitude start_field = 240 ramp_rate = 0.2/60 field = start_field + delta_time*ramp_rate Q = frequency/half Q_smaller = frequency/larger Q_larger = frequency/smaller self.vna.marker_peak_search_second[r_chnl] self.vna.marker_min_search_second[l_chnl] L_x = self.vna.marker_X_second[l_chnl].magnitude L_y = self.vna.marker_Y_second[l_chnl].magnitude R_x = self.vna.marker_X_second[r_chnl].magnitude R_y = self.vna.marker_Y_second[r_chnl].magnitude delta_x = R_x - L_x delta_y = R_y - L_y self.vna.marker_X_second[v_chnl]=(L_x+R_x)/2*Hz self.times.append(delta_time) self.freqs.append(frequency) self.Qs.append(Q) self.Qis.append(Q_smaller) self.Qes.append(Q_larger) self.dips.append(A) values = { 't': self.times, 'f': self.freqs, 'Q': self.Qs, 'Qi': self.Qis, 'Qe': self.Qes, 'dip': self.dips, } self.Record_data_time.acquire(values) with open('D:/MW data/test/20190810/cavity/scan_5/YZscan/scan10/{}.txt'.format(name),'a') as file: write_str='%f %f %f %f %f %f %f %f %f %f %f %f %f %f %f\n'%(frequency,power,delta_time,A,half,Q,Q_smaller,Q_larger,L_x,L_y,R_x,R_y,field,delta_x,delta_y) file.write(write_str) self.vna.save_csv('D:/MW data/test/20190810/cavity/scan_5/YZscan/scan10/amplitude/{}.csv'.format(field)) self.vna.save_csv_second('D:/MW data/test/20190810/cavity/scan_5/YZscan/scan10/phase/{}.csv'.format(field)) time.sleep(t) return