def __init__(self, host, index, katcp_port=7147, boffile=None,
connect=True, config=None):
FpgaHost.__init__(self, host, katcp_port=katcp_port,
boffile=boffile, connect=connect)
self.config = config
self.index = index
if self.config is not None:
self.vacc_len = int(self.config['xeng_accumulation_len'])
self.x_per_fpga = int(self.config['x_per_fpga'])
else:
self.x_per_fpga = -1
def __init__(self, host, katcp_port=7147, boffile=None,
connect=True, config=None):
FpgaHost.__init__(self, host, katcp_port=katcp_port,
boffile=boffile, connect=connect)
self.config = config
if self.config is not None:
self.vacc_len = int(self.config['xeng_accumulation_len'])
self.x_per_fpga = int(self.config['x_per_fpga'])
# TODO - and if there is no config and this was made on a running device?
# something like set it to -1, if it's accessed when -1 then try and discover it
self.x_per_fpga = 4
def get_system_information(self, filename=None, fpg_info=None, **kwargs):
"""
Get system information and build D-engine sources
:param filename:
:param fpg_info:
:return:
"""
FpgaHost.get_system_information(
self, filename=filename, fpg_info=fpg_info, **kwargs)
self.sine_sources.clear()
self.noise_sources.clear()
self.pulsar_sources.clear()
self.outputs.clear()
for reg in self.registers:
sin_name = get_prefixed_name('freq_cwg', reg.name)
noise_name = get_prefixed_name('scale_wng', reg.name)
pulsar_name = get_prefixed_name('freq_pulsar', reg.name)
output_scale_name = get_prefixed_name('scale_out', reg.name)
if sin_name is not None:
scale_reg_postfix = ('_' + sin_name if reg.name.endswith(
'_' + sin_name) else sin_name)
scale_reg = getattr(self.registers, 'scale_cwg' +
scale_reg_postfix)
repeat_en_reg_name = 'rpt_en_cwg' + scale_reg_postfix
repeat_len_reg_name = 'rpt_length_cwg{}'.format(scale_reg_postfix)
repeat_en_reg = getattr(self.registers,
repeat_en_reg_name, None)
repeat_len_reg = getattr(self.registers,
repeat_len_reg_name, None)
repeat_len_field_name = 'repeat_length'
setattr(self.sine_sources, 'sin_' + sin_name, SineSource(
reg, scale_reg, sin_name,
repeat_len_register=repeat_len_reg,
repeat_en_register=repeat_en_reg,
repeat_len_field_name=repeat_len_field_name))
elif noise_name is not None:
setattr(self.noise_sources, 'noise_' + noise_name,
NoiseSource(reg, noise_name))
elif pulsar_name is not None:
scale_reg_postfix = ('_' + pulsar_name if reg.name.endswith(
'_' + pulsar_name) else pulsar_name)
scale_reg = getattr(self.registers, 'scale_pulsar' + scale_reg_postfix)
setattr(self.pulsar_sources, 'pulsar_' + pulsar_name,
PulsarSource(reg, scale_reg, pulsar_name))
elif output_scale_name is not None:
# TODO TEMP hack due to misnamed register
if output_scale_name.startswith('arb'):
continue
setattr(self.outputs, 'out_' + output_scale_name,
Output(output_scale_name, reg, self.registers.control))
def __init__(self, host, katcp_port=7147, boffile=None, connect=True, config=None):
FpgaHost.__init__(self, host, katcp_port=katcp_port, boffile=boffile, connect=connect)
self._config = config
self.data_sources = [] # a list of DataSources received by this f-engine host
self.eqs = {} # a dictionary, indexed on source name, containing tuples of poly and bram name
if config is not None:
self.num_fengines = int(config['f_per_fpga'])
self.ports_per_fengine = int(config['ports_per_fengine'])
self.fft_shift = int(config['fft_shift'])
self.n_chans = int(config['n_chans'])
else:
self.num_fengines = None
self.ports_per_fengine = None
self.fft_shift = None
self.n_chans = None
def __init__(self, host, index, katcp_port=7147, bitstream=None,
connect=True, config=None, **kwargs):
FpgaHost.__init__(self, host=host, katcp_port=katcp_port,
bitstream=bitstream, connect=connect, transport=SkarabTransport)
try:
descriptor = kwargs['descriptor']
except KeyError:
descriptor = 'InstrumentName'
# This will always be a kwarg
self.getLogger = kwargs['getLogger']
logger_name = '{}_xhost-{}-{}'.format(descriptor, str(index), host)
# Why is logging defaulted to INFO, what if I do not want to see the info logs?
logLevel = kwargs.get('logLevel', INFO)
result, self.logger = self.getLogger(logger_name=logger_name,
log_level=logLevel, **kwargs)
if not result:
# Problem
errmsg = 'Unable to create logger for {}'.format(logger_name)
raise ValueError(errmsg)
self.logger.debug('Successfully created logger for {}'.format(logger_name))
self.config = config
self.index = index
self.acc_len = None
self.n_ants = None
self.x_per_fpga = None
self.xeng_accumulation_len = None
self.n_chans = None
self.sample_rate_hz = None
if self.config is not None:
xcfg = self.config['xengine']
fcfg = self.config['fengine']
ccfg = self.config['FxCorrelator']
self.x_per_fpga = int(xcfg['x_per_fpga'])
self.acc_len = int(xcfg['accumulation_len'])
self.xeng_accumulation_len = int(xcfg['xeng_accumulation_len'])
self.n_chans = int(fcfg['n_chans'])
self.n_ants = int(ccfg['n_ants'])
self.sample_rate_hz = int(ccfg['sample_rate_hz'])
self._vaccs_per_sec_last_readtime = None
self._vaccs_per_sec_last_values = None
self.host_type = 'xhost'
def __init__(self, host, katcp_port=7147, bitstream=None,
connect=True, config=None, config_file=None, **kwargs):
"""
:param host:
:param katcp_port:
:param bitstream:
:param connect:
:param config:
"""
FpgaHost.__init__(self, host=host, katcp_port=katcp_port, **kwargs)
if config is not None and config_file is not None:
LOGGER.warn('config file and config supplied, defaulting to config')
self.config = config or parse_ini_file(config_file)['dsimengine']
self.bitstream = bitstream
self.sine_sources = AttributeContainer()
self.noise_sources = AttributeContainer()
self.pulsar_sources = AttributeContainer()
self.outputs = AttributeContainer()
