def tune_if(snap_hosts, fpgfile=None, target_rms=TARGET_RMS):
"""
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_dict = {
snap: ata_snap_fengine.AtaSnapFengine(
snap, transport=casperfpga.KatcpTransport)
for snap in snap_hosts
}
elif type(snap_hosts[0]) == ata_snap_fenging.AtaSnapFengine:
snaps_dict = {snap.hostname: snap for snap in snap_hosts}
if not fpgfile:
fpgfile = FPGFILE
for feng in snaps_dict.values():
feng.fpga.get_system_information(fpgfile)
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()
logger.info("Tuning: %s" % if_tab.snap_hostname)
logger.info("Attemp chans: %s" % ant_ch)
prev_attn = np.array([START_ATTN] * len(ant_ch))
for i in range(3):
prev_attn[prev_attn > MAX_ATT] = MAX_ATT
prev_attn[prev_attn < MIN_ATT] = MIN_ATT
_setatten(ant_ch, prev_attn)
rms = []
for snap_name in list(if_tab.snap_hostname.values):
snap = snaps_dict[snap_name]
set_device_lock(snap_name)
x, y = snap.adc_get_samples()
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)
logger.info("IF tuner ended")
def init_snaps(snap_list, load_system_information=False):
logger = logger_defaults.getModuleLogger(__name__)
logger.info("Initialising snaps: %s" % snap_list)
snaps = []
for snap_name in snap_list:
if snap_name.startswith("frb-snap"):
snaps.append(
ata_snap_fengine.AtaSnapFengine(
snap_name, transport=casperfpga.KatcpTransport))
elif snap_name.startswith("rfsoc"):
pipeline_id = int(snap_name[-1])
snaps.append(
ata_rfsoc_fengine.AtaRfsocFengine(snap_name,
pipeline_id=pipeline_id - 1))
if load_system_information:
get_system_information(snaps)
return snaps
def init_snaps(snap_list, get_system_information=False):
logger = logger_defaults.getModuleLogger(__name__)
logger.info("Initialising snaps: %s" % snap_list)
snaps = [
ata_snap_fengine.AtaSnapFengine(snap,
transport=casperfpga.KatcpTransport)
for snap in snap_list
]
if get_system_information:
if type(get_system_information) == bool:
from .snap_config import get_ata_cfg
ata_cfg = get_ata_cfg()
fpg_file = ata_cfg['SNAPFPG']
elif type(get_system_information) == str:
fpg_file = get_system_information
for snap in snaps:
snap.fpga.get_system_information(fpg_file)
return snaps
from ata_snap import ata_snap_fengine
import casperfpga
n = [1, 2, 3, 4, 6, 8, 9, 10, 11, 12]
n = [5, 7]
hosts = ['frb-snap%i-pi' % i for i in n]
fengs = [
ata_snap_fengine.AtaSnapFengine(host, transport=casperfpga.KatcpTransport)
for host in hosts
]
for feng in fengs:
feng.fpga.get_system_information(
"/home/obsuser/src/ata_snap/snap_adc5g_feng_rpi/outputs/snap_adc5g_feng_rpi_2020-10-29_1727.fpg"
)
feng.fpga.write_int('sync_sel', 1)
# user flags
with open(args.configfile, 'r') as fh:
config = yaml.load(fh, Loader=yaml.SafeLoader)
config['acclen'] = args.acclen or config['acclen']
config['spectrometer_dest'] = args.specdest or config['spectrometer_dest']
config['dest_port'] = args.dest_port or config['dest_port']
if args.usetapcp:
transport = casperfpga.TapcpTransport
else:
transport = casperfpga.KatcpTransport
logger.info("Connecting to %s" % args.host)
feng = ata_snap_fengine.AtaSnapFengine(args.host,
transport=transport,
feng_id=args.feng_id)
if not args.skipprog:
logger.info("Programming %s with %s" % (args.host, args.fpgfile))
feng.program(args.fpgfile)
else:
logger.info("Skipping programming because the --skipprog flag was used")
# If we're not programming we need to load the FPG information
feng.fpga.get_system_information(args.fpgfile)
# Disable ethernet output before doing anything
feng.eth_enable_output(False)
feng.set_accumulation_length(config['acclen'])
conn = ThreadPoolExecutor(max_workers=self.nsnap)
while True:
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 = [ata_snap_fengine.AtaSnapFengine(snap,
transport=casperfpga.KatcpTransport)
for snap in snaps]
for feng in fengs:
feng.fpga.get_system_information(ATA_CFG['SNAPFPG'])
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,
def run(host, fpgfile, configfile,
sync=False,
mansync=False,
tvg=False,
feng_id=0,
dest_port=None,
skipprog=False,
usetapcp=False,
eth_spec=False,
eth_volt=False,
acclen=None,
specdest=None
):
logger = logging.getLogger(__file__)
logger.setLevel(logging.INFO)
handler = logging.StreamHandler(sys.stdout)
handler.setLevel(logging.INFO)
logger.addHandler(handler)
assert not (eth_spec and eth_volt), "Can't use both --eth_spec and --eth_volt options!"
# Load configuration file and override parameters with
# user flags
with open(configfile, 'r') as fh:
config = yaml.load(fh, Loader=yaml.SafeLoader)
config['acclen'] = acclen or config['acclen']
config['spectrometer_dest'] = specdest or config['spectrometer_dest']
config['dest_port'] = dest_port or config['dest_port']
if usetapcp:
transport = casperfpga.TapcpTransport
else:
transport = casperfpga.KatcpTransport
logger.info("Connecting to %s" % host)
feng = ata_snap_fengine.AtaSnapFengine(host,
transport=transport,
feng_id=feng_id)
if not skipprog:
logger.info("Programming %s with %s" % (host, fpgfile))
feng.program(fpgfile)
else:
logger.info("Skipping programming because the --skipprog flag was used")
# If we're not programming we need to load the FPG information
feng.fpga.get_system_information(fpgfile)
# Disable ethernet output before doing anything
feng.eth_enable_output(False)
feng.set_accumulation_length(config['acclen'])
# Use the same coefficients for both polarizations
feng.eq_load_coeffs(0, config['coeffs'])
feng.eq_load_coeffs(1, config['coeffs'])
feng.eq_load_test_vectors(0, list(range(feng.n_chans_f)))
feng.eq_load_test_vectors(1, list(range(feng.n_chans_f)))
feng.eq_test_vector_mode(enable=tvg)
feng.spec_test_vector_mode(enable=tvg)
# Configure arp table
for ip, mac in config['arp'].items():
print ("Configuring ip: %s with mac: %x" %(ip, mac))
for ethn, eth in enumerate(feng.fpga.gbes):
eth.set_single_arp_entry(ip, mac)
voltage_config = config.get('voltage_output', None)
n_interfaces = voltage_config.get('n_interfaces', feng.n_interfaces)
for i in range(n_interfaces):
ip = config["interfaces"][feng.fpga.host][i]
mac = config["arp"][ip]
port = 10000
eth = feng.fpga.gbes['eth%i_core' %i]
eth.configure_core(mac, ip, port)
if eth_spec:
feng.spec_set_destination(config['spectrometer_dest'])
if voltage_config is not None:
n_chans = voltage_config['n_chans']
start_chan = voltage_config['start_chan']
dests = voltage_config['dests']
logger.info('Voltage output sending channels %d to %d' % (start_chan, start_chan+n_chans-1))
logger.info('Destination IPs: %s' %dests)
logger.info('Using %d interfaces' % n_interfaces)
feng.select_output_channels(start_chan, n_chans, dests, n_interfaces=n_interfaces)
feng.eth_set_dest_port(config['dest_port'])
if eth_spec:
feng.eth_set_mode('spectra')
feng.fpga.write_int('corr_feng_id', feng_id)
elif eth_volt:
feng.eth_set_mode('voltage')
if sync:
if not mansync:
feng.sync_wait_for_pps()
feng.sync_arm(manual_trigger=mansync)
# Reset ethernet cores prior to enabling
feng.eth_reset()
if eth_spec or eth_volt:
logger.info('Enabling Ethernet output')
feng.eth_enable_output(True)
else:
logger.info('Not enabling Ethernet output, since neither voltage or spectrometer 10GbE output flags were set.')
logger.info("Initialization complete!")