def update_from_bitsnap(self, info):
"""Update this device with information from a bitsnap container.
:type self: Snap
:param info: device information dictionary containing Simulink block information
"""
def clean_fields(fstr):
_fstr = fstr.replace('[', '').replace(']', '').strip().replace(
', ', ',').replace(' ', ' ')
if (_fstr.find(' ') > -1) and (_fstr.find(',') > -1):
LOGGER.error(
'Parameter string %s contains spaces and commas as delimiters. This is confusing.'
% fstr)
if _fstr.find(' ') > -1:
_flist = _fstr.split(' ')
else:
_flist = _fstr.split(',')
_rv = []
for _fname in _flist:
if _fname.strip() == '':
LOGGER.DEBUG('Throwing away empty field in snapshot %s' %
self.name)
else:
_rv.append(_fname)
return _rv
self.block_info = info
if self.width_bits != int(info['snap_data_width']):
raise ValueError('Snap and matched bitsnap widths do not match.')
if self.length_bytes != pow(2, int(
info['snap_nsamples'])) * (self.width_bits / 8):
raise ValueError('Snap and matched bitsnap lengths do not match.')
field_names = clean_fields(info['io_names'])
field_widths = clean_fields(info['io_widths'])
field_types = clean_fields(info['io_types'])
field_bps = clean_fields(info['io_bps'])
field_names.reverse()
field_widths.reverse()
field_types.reverse()
field_bps.reverse()
self.fields_clear()
for n, fn in enumerate(field_names):
try:
bitwidth = int(field_widths[n])
except ValueError:
bitwidth = eval(field_widths[n])
field = bitfield.Field(name=fn,
numtype=int(field_types[n]),
width_bits=bitwidth,
binary_pt=int(field_bps[n]),
lsb_offset=-1)
self.field_add(field, auto_offset=True)
def update_from_bitsnap(self, info):
"""
Update this device with information from a bitsnap container.
:type self: Snap
:param info: device information dictionary containing Simulink block
information
"""
clean_fields = bitfield.clean_fields
self.block_info = info
if self.width_bits != int(info['snap_data_width']):
raise ValueError('Snap and matched bitsnap widths do not match.')
samples_bytes = pow(2, int(
info['snap_nsamples'])) * (self.width_bits / 8)
if self.length_bytes != samples_bytes:
raise ValueError('Snap and matched bitsnap lengths do not match.')
fields = {
'names': clean_fields(self.name, 'snapshot', info['io_names']),
'widths': clean_fields(self.name, 'snapshot', info['io_widths']),
'types': clean_fields(self.name, 'snapshot', info['io_types']),
'bps': clean_fields(self.name, 'snapshot', info['io_bps'])
}
fields['names'].reverse()
fields['widths'].reverse()
fields['types'].reverse()
fields['bps'].reverse()
self.fields_clear()
len_names = len(fields['names'])
for fld in ['widths', 'types', 'bps']:
# convert the number-based fields to integers
for n, val in enumerate(fields[fld]):
try:
intvalue = int(val)
except ValueError:
intvalue = eval(val)
fields[fld][n] = intvalue
# accommodate new snapshots where the fields may have length one
len_fld = len(fields[fld])
if len_fld != len_names:
if len_fld != 1:
raise RuntimeError('%i names, but %i %s?' %
(len_names, len_fld, fld))
fields[fld] = [fields[fld][0]] * len_names
# construct the fields and add them to this BitField
for ctr, name in enumerate(fields['names']):
field = bitfield.Field(name=name,
numtype=fields['types'][ctr],
width_bits=fields['widths'][ctr],
binary_pt=fields['bps'][ctr],
lsb_offset=-1)
self.field_add(field, auto_offset=True)
def _process_info_tabbed(self):
LOGGER.warn('Tabbed registers are deprecated!')
numios = int(self.block_info['numios'])
for ctr in range(numios, 0, -1):
if self.block_info['arith_type%i' % ctr] == 'Boolean':
atype = 2
elif self.block_info['arith_type%i' % ctr] == 'Unsigned':
atype = 0
else:
atype = 1
field = bitfield.Field(self.block_info['name%i' % ctr], atype,
int(self.block_info['bitwidth%i' % ctr]),
int(self.block_info['bin_pt%i' % ctr]), -1)
self.field_add(field, auto_offset=True)
def process_info(self, info):
"""
Set this Register's extra information.
"""
if (info is None) or (info == {}):
return
self.block_info = info
self.fields_clear()
if 'mode' in self.block_info.keys():
self._process_info_current()
elif 'numios' in self.block_info.keys():
# aborted tabbed one
self._process_info_tabbed()
elif 'name' in self.block_info.keys():
# oldest
LOGGER.error('Old registers are deprecated!')
self.field_add(bitfield.Field('reg', 0, 32, 0, 0))
else:
LOGGER.error(
'That is a seriously old register - please swap it out!')
LOGGER.error(self)
LOGGER.error(self.block_info)
self.field_add(bitfield.Field('reg', 0, 32, 0, 0))
def __init__(self, parent, name, width_bits, address, length_bytes,
device_info=None):
super(Snap, self).__init__(name=name, width_bits=width_bits,
address=address, length_bytes=length_bytes)
self.parent = parent
self.block_info = device_info
self.field_add(bitfield.Field(name='data', numtype=0,
width_bits=self.width_bits,
binary_pt=0, lsb_offset=0))
self.control_registers = {
'control': {'register': None, 'name': self.name + '_ctrl'},
'status': {'register': None, 'name': self.name + '_status'},
'trig_offset': {'register': None,
'name': self.name + '_trig_offset'},
'extra_value': {'register': None, 'name': self.name + '_val'},
'tr_en_cnt': {'register': None, 'name': self.name + '_tr_en_cnt'}}
LOGGER.debug('New Snap %s' % self)
def _process_info_current(self):
# current one
clean_fields = bitfield.clean_fields
# a single value may have been used for width, type or binary point
fields = {
'names':
clean_fields(self.name, 'register', self.block_info['names']),
'widths':
clean_fields(self.name, 'register', self.block_info['bitwidths']),
'types':
clean_fields(self.name, 'register',
self.block_info['arith_types']),
'bps':
clean_fields(self.name, 'register', self.block_info['bin_pts'])
}
fields['names'].reverse()
fields['widths'].reverse()
fields['types'].reverse()
fields['bps'].reverse()
len_names = len(fields['names'])
for fld in ['widths', 'types', 'bps']:
# convert the number-based fields to integers
for n, val in enumerate(fields[fld]):
try:
intvalue = int(val)
except ValueError:
intvalue = eval(val)
fields[fld][n] = intvalue
# accommodate new snapshots where the fields may have length one
len_fld = len(fields[fld])
if len_fld != len_names:
if len_fld != 1:
raise RuntimeError('%i names, but %i %s?' %
(len_names, len_fld, fld))
fields[fld] = [fields[fld][0]] * len_names
# construct the fields and add them to this BitField
for ctr, name in enumerate(fields['names']):
field = bitfield.Field(name, fields['types'][ctr],
fields['widths'][ctr], fields['bps'][ctr],
-1)
self.field_add(field, auto_offset=True)
def _process_info_current(self):
# current one
def clean_fields(fstr):
_fstr = fstr.replace('[', '').replace(']', '').strip().replace(
', ', ',').replace(' ', ' ')
if (_fstr.find(' ') > -1) and (_fstr.find(',') > -1):
LOGGER.error(
'Parameter string %s contains spaces and commas as delimiters. '
'This is confusing.' % fstr)
if _fstr.find(' ') > -1:
_flist = _fstr.split(' ')
else:
_flist = _fstr.split(',')
_rv = []
for _fname in _flist:
if _fname.strip() == '':
LOGGER.DEBUG('Throwing away empty field in register %s' %
self.name)
else:
_rv.append(_fname)
return _rv
# a single value may have been used for width, type or binary point
field_names = clean_fields(self.block_info['names'])
field_widths = clean_fields(self.block_info['bitwidths'])
field_types = clean_fields(self.block_info['arith_types'])
field_bin_pts = clean_fields(self.block_info['bin_pts'])
field_names.reverse()
field_widths.reverse()
field_types.reverse()
field_bin_pts.reverse()
# convert the number-based fields to integers
for avar in [field_widths, field_bin_pts, field_types]:
for index, value in enumerate(avar):
try:
intvalue = int(value)
except ValueError:
intvalue = eval(value)
avar[index] = intvalue
num_fields = len(field_names)
if self.block_info['mode'] == 'fields of equal size':
for avar in [field_widths, field_bin_pts, field_types]:
if len(avar) != 1:
raise RuntimeError(
'register %s has equal size fields set, field parameters != 1?',
self.name)
avar[:] = num_fields * avar
elif self.block_info['mode'] == 'fields of arbitrary size':
if num_fields == 1:
if (len(field_widths) != 1) or (len(field_types) != 1) or (
len(field_bin_pts) != 1):
raise RuntimeError(
'register %s has equal size fields set, unequal field parameters?',
self.name)
else:
for avar in [field_widths, field_bin_pts, field_types]:
len_avar = len(avar)
if len_avar != num_fields:
if len_avar == 1:
avar[:] = num_fields * avar
else:
raise RuntimeError(
'register %s: number of fields is %s, given %s',
self.name, num_fields, len_avar)
for ctr, name in enumerate(field_names):
field = bitfield.Field(name, field_types[ctr], field_widths[ctr],
field_bin_pts[ctr], -1)
self.field_add(field, auto_offset=True)