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],
