def sync(stream_list=None, all_snaps=False, check_sync_all=True, publish_global_key=False): if all_snaps: ATA_SNAP_TAB = snap_config.get_ata_snap_tab() stream_list = [snap for snap in ATA_SNAP_TAB.snap_hostname] if check_sync_all: print(*stream_list, sep='\n') response = input( 'Are you sure you want to sync all the snaps (above) (Y/n): ') if len(response) > 0 and response[0] in ['n', 'N']: print('Aborting...') return if stream_list is not None and len(stream_list) > 0: print("Syncing: ") print(stream_list) fengs = snap_control.init_snaps(stream_list) host_unique_fengs = hpguppi_auxillary.filter_unique_fengines(fengs) if len(host_unique_fengs) < len(fengs): fengs = host_unique_fengs print('Simplified F-Engines to unique hosts:', [feng.host for feng in fengs]) sync_time = snap_control.arm_snaps(fengs) print("Synctime is: %i" % sync_time) if publish_global_key: print("Writing sync time to redis database") r = redis.Redis(host='redishost') r.set('SYNCTIME', sync_time) print(r.get('SYNCTIME'))
def collect_feng_obj(antlo_stream_list=None, all_streams=False, check_stop_all=True): if all_streams: ATA_SNAP_TAB = snap_config.get_ata_snap_tab() antstream_hostname_list_to_silence = [ stream for stream in ATA_SNAP_TAB.snap_hostname ] if check_stop_all: print(*antstream_hostname_list_to_silence, sep='\n') response = input( 'Are you sure you want to control the ethernet of all the streams (above) (Y/n): ' ) if len(response) > 0 and response[0] in ['n', 'N']: print('Aborting...') return None elif antlo_stream_list is not None and len(antlo_stream_list) > 0: print( hpguppi_auxillary.get_stream_hostname_dict_for_antenna_names( antlo_stream_list)) antstream_hostname_list_to_silence = hpguppi_auxillary.get_stream_hostname_per_antenna_names( antlo_stream_list) return hpguppi_auxillary.filter_unique_fengines( snap_control.init_snaps(antstream_hostname_list_to_silence))
if antnames is not None: for ant_name in stream_antlo_names: if ant_name in antnames: hpguppi_redis_reset_chans.append( hpguppi_auxillary.redis_set_channel_from_get_channel( hpguppi_instance_redis_setchan)) antlo_names.extend(antnames) break if args.stop_all_eth_first: antstream_hostname_list_to_silence = hpguppi_auxillary.get_stream_hostname_per_antenna_names( antlo_names) print('antstream_hostname to silence', antstream_hostname_list_to_silence) if not args.dry_run: fengs = snap_control.init_snaps(antstream_hostname_list_to_silence) snap_control.stop_snaps(fengs) if not args.dry_run: hpguppi_record_in.record_in(hashpipe_targets=hpguppi_redis_reset_chans, reset=True) else: print('hpguppi_daq redis channels to reset:', hpguppi_redis_reset_chans) if not args.sync_only: rfsoc_hostname_regex = r'(?P<boardname>.*)-(?P<pipeline>\d+)$' rfsoc_hostname_configurations_dict = {} multi_group_config = None if args.group_config_stem is not None: with open(stream_cfgs[0], 'r') as fh:
def _get_sync_time_for_streams(stream_hostnames): fengs = snap_control.init_snaps( hpguppi_auxillary.filter_unique_hostnames(stream_hostnames)) sync_times = [feng.fpga.read_int('sync_sync_time') for feng in fengs] snap_control.disconnect_snaps(fengs) return sync_times
from SNAPobs import snap_control hosts = ["frb-snap5-pi", "rfsoc1-ctrl-1", "rfsoc1-ctrl-2"] snaps = snap_control.init_snaps(hosts) snap_control.get_system_information(snaps) print(snaps)
def tune_if(snap_hosts): """ Function to tune the IF """ logger = logger_defaults.getModuleLogger(__name__) logger.info("IF tuner entered") assert type(snap_hosts) == list if type(snap_hosts[0]) == str: snaps = snap_control.init_snaps(snap_hosts) snaps_dict = { snap_name: snaps[isnap_name] for isnap_name, snap_name in enumerate(snap_hosts) } #elif type(snap_hosts[0]) == ata_snap_fenging.AtaSnapFengine: # snaps_dict = {snap.hostname:snap for snap in snap_hosts} snap_control.get_system_information(list(snaps_dict.values())) snap_names = list(snaps_dict.keys()) if_tab = ATA_SNAP_IF[ATA_SNAP_IF.snap_hostname.isin(snap_names)] #ant_ch = if_tab.values[:,1:].flatten() att_numbs = if_tab.module.unique() for att_num in att_numbs: print(if_tab) print(att_num) if_tab_sub = if_tab[if_tab.module == att_num] print(if_tab_sub) ant_ch = if_tab_sub[['chx', 'chy']].values.flatten() logger.info("Tuning: %s" % if_tab.snap_hostname) logger.info("Attemp chans: %s" % ant_ch) prev_attn = np.array([START_ATTN] * len(ant_ch)) target_rms = [] for host_name in if_tab_sub.snap_hostname: print(host_name) if host_name.startswith("frb-snap"): target_rms.append(17) #X pol target_rms.append(17) #Y pol elif host_name.startswith("rfsoc"): target_rms.append(1024) #X pol target_rms.append(1024) #Y pol else: print("Something is wrong") sys.exit(-1) target_rms = np.array(target_rms) for i in range(3): if np.any(prev_attn > MAX_ATT): warn_ant_ch = ant_ch[prev_attn > MAX_ATT] warn_prev_attn = prev_attn[prev_attn > MAX_ATT] warnings.warn( "Trying to set attenuator on channels %s to values %s, which is more than max [%i]" % (list(warn_ant_ch), list(warn_prev_attn), MAX_ATT)) prev_attn[prev_attn > MAX_ATT] = MAX_ATT if np.any(prev_attn < MIN_ATT): warn_ant_ch = ant_ch[prev_attn < MIN_ATT] warn_prev_attn = prev_attn[prev_attn < MIN_ATT] warnings.warn( "Trying to set attenuator on channels %s to values %s, which is less than min [%i]" % (list(warn_ant_ch), list(warn_prev_attn), MIN_ATT)) prev_attn[prev_attn < MIN_ATT] = MIN_ATT _setatten(ant_ch, prev_attn, att_num) rms = [] for snap_name in list(if_tab_sub.snap_hostname.values): snap = snaps_dict[snap_name] set_device_lock(snap_name) x, y = snap.adc_get_samples() x = np.array(x) y = np.array(y) print(np.std(x), np.std(y)) release_device_lock(snap_name) rms.append(x.std()) rms.append(y.std()) rms = np.array(rms) d_attn = 20 * np.log10(rms / target_rms) prev_attn = round50th(prev_attn + d_attn) snap_control.disconnect_snaps(snaps) logger.info("IF tuner ended")
ret = {} failed_antname_nolo_list = [] for antname_nolo in antname_nolo_list: try: ret.update(get_func([antname_nolo])) except: failed_antname_nolo_list.append(antname_nolo) return ret, failed_antname_nolo_list ### Begin streams_to_marshall, antenna_names = generate_stream_antnames_to_marshall() antname_nolo_list = list(set([ant[:2] for ant in antenna_names])) # Create the AtaSnapFengine list from the names fengs = snap_control.init_snaps( streams_to_marshall) #, load_system_information=False) hostname_feng_dict = {feng.host: feng for feng in fengs} last_consulted_anttab = time.time() last_groups = [] last_destinations = [] last_skyfreq_mapping, _ = hpguppi_populate_meta._get_stream_mapping( streams_to_marshall) last_skyfreq_mapping = collect_values_from_dict(last_skyfreq_mapping, streams_to_marshall) last_az_el, failed_antname_nolo_list = ata_control_get_safe( antname_nolo_list, ata_control.get_az_el) safe_antname_nolo_list = list(last_az_el.keys()) last_eph_source = ata_control.get_eph_source(safe_antname_nolo_list)
#!/home/obsuser/miniconda3/envs/ATAobs/bin/python from SNAPobs import snap_control snap_list = ['frb-snap1-pi'] fengs = snap_control.init_snaps(snap_list) snap_control.stop_snaps(fengs) snap_control.arm_snaps(fengs) snap_control.enable_ethernet_output(fengs)
t = time.time() snaps_res = conn.map(self.get_bp_thread, self.fengs, repeat(self.defs)) self.snaps_res = { host: data for host, data in zip(self.hosts, snaps_res) } time.sleep(1) LOs = pd.unique(ATA_SNAP_TAB.LO) cfreq_thread = cfreqThread(LOs) cfreq_thread.daemon = True cfreq_thread.start() fengs = snap_control.init_snaps(snaps, True) snap_thread = SnapThread(fengs) snap_thread.daemon = True snap_thread.start() # give the thread sometime to pull data time.sleep(10) snaps_res = snap_thread.snaps_res FIGS = {} for snap in fengs: fig = make_subplots( rows=1, cols=2, column_widths=[0.8, 0.2],