def fit_profile_show():
unit_values = []
unit_dict = dict()
for message_type in MESSAGE_TYPES.values():
for field in message_type.fields.values():
unit_values.append(field.units)
unit_dict[str(field.name)] = field.units
if field.components:
for component in field.components:
unit_values.append(component.units)
unit_dict[component.name] = component.units
if field.subfields:
for subfield in field.subfields:
unit_values.append(subfield.units)
unit_dict[subfield.name] = subfield.units
if subfield.components:
for component in subfield.components:
unit_values.append(component.units)
unit_dict[component.name] = component.units
# unit_values = filter(None, unit_values)
# for unit_value in sorted(set(unit_values)):
# print(format(unit_value))
# unit_dict = unit_dict.pop(filter(None, unit_dict.values()))
print(unit_dict)
def _parse_definition_message(self, header):
# Read reserved byte and architecture byte to resolve endian
endian = '>' if self._read_struct('xB') else '<'
# Read rest of header with endian awareness
global_mesg_num, num_fields = self._read_struct('HB', endian=endian)
mesg_type = MESSAGE_TYPES.get(global_mesg_num)
field_defs = []
for n in range(num_fields):
field_def_num, field_size, base_type_num = self._read_struct('3B', endian=endian)
# Try to get field from message type (None if unknown)
field = mesg_type.fields.get(field_def_num) if mesg_type else None
base_type = BASE_TYPES.get(base_type_num, BASE_TYPE_BYTE)
if (field_size % base_type.size) != 0:
warnings.warn(
"Invalid field size %d for field '%s' of type '%s' (expected a multiple of %d); falling back to byte encoding." % (
field_size, field.name, base_type.name, base_type.size)
)
base_type = BASE_TYPE_BYTE
# If the field has components that are accumulators
# start recording their accumulation at 0
if field and field.components:
for component in field.components:
if component.accumulate:
accumulators = self._accumulators.setdefault(global_mesg_num, {})
accumulators[component.def_num] = 0
field_defs.append(FieldDefinition(
field=field,
def_num=field_def_num,
base_type=base_type,
size=field_size,
))
dev_field_defs = []
if header.is_developer_data:
num_dev_fields = self._read_struct('B', endian=endian)
for n in range(num_dev_fields):
field_def_num, field_size, dev_data_index = self._read_struct('3B', endian=endian)
field = self.get_dev_type(dev_data_index, field_def_num)
dev_field_defs.append(DevFieldDefinition(
field=field,
dev_data_index=dev_data_index,
def_num=field_def_num,
size=field_size
))
def_mesg = DefinitionMessage(
header=header,
endian=endian,
mesg_type=mesg_type,
mesg_num=global_mesg_num,
field_defs=field_defs,
dev_field_defs=dev_field_defs,
)
self._local_mesgs[header.local_mesg_num] = def_mesg
return def_mesg
def _parse_definition_message(self, header):
# Read reserved byte and architecture byte to resolve endian
endian = '>' if self._read_struct('xB') else '<'
# Read rest of header with endian awareness
global_mesg_num, num_fields = self._read_struct('HB', endian=endian)
mesg_type = MESSAGE_TYPES.get(global_mesg_num)
field_defs = []
for n in range(num_fields):
field_def_num, field_size, base_type_num = self._read_struct('3B', endian=endian)
# Try to get field from message type (None if unknown)
field = mesg_type.fields.get(field_def_num) if mesg_type else None
base_type = BASE_TYPES.get(base_type_num, BASE_TYPE_BYTE)
if (field_size % base_type.size) != 0:
# NOTE: we could fall back to byte encoding if there's any
# examples in the wild. For now, just throw an exception
raise FitParseError("Invalid field size %d for type '%s' (expected a multiple of %d)" % (
field_size, base_type.name, base_type.size))
# If the field has components that are accumulators
# start recording their accumulation at 0
if field and field.components:
for component in field.components:
if component.accumulate:
accumulators = self._accumulators.setdefault(global_mesg_num, {})
accumulators[component.def_num] = 0
field_defs.append(FieldDefinition(
field=field,
def_num=field_def_num,
base_type=base_type,
size=field_size,
))
dev_field_defs = []
if header.is_developer_data:
num_dev_fields = self._read_struct('B', endian=endian)
for n in range(num_dev_fields):
field_def_num, field_size, dev_data_index = self._read_struct('3B', endian=endian)
field = get_dev_type(dev_data_index, field_def_num)
dev_field_defs.append(DevFieldDefinition(
field=field,
dev_data_index=dev_data_index,
def_num=field_def_num,
size=field_size
))
def_mesg = DefinitionMessage(
header=header,
endian=endian,
mesg_type=mesg_type,
mesg_num=global_mesg_num,
field_defs=field_defs,
dev_field_defs=dev_field_defs,
)
self._local_mesgs[header.local_mesg_num] = def_mesg
return def_mesg
def fit_message_all_show(fitfile=None):
if fitfile is None:
fit_profile_show()
return
unit_dict = dict()
for message_type in MESSAGE_TYPES.values():
msg_dict = dict()
msg_dict = list(fitfile.get_messages(name=message_type.name))
if len(msg_dict) > 0:
unit_dict[message_type.name] = msg_dict.copy()
fit_msg_type_list.append(message_type.name)
def _parse_definition_message(self, header):
# Read reserved byte and architecture byte to resolve endian
endian = '>' if self._read_struct('xB') else '<'
# Read rest of header with endian awareness
global_mesg_num, num_fields = self._read_struct('HB', endian=endian)
mesg_type = MESSAGE_TYPES.get(global_mesg_num)
field_defs = []
for n in range(num_fields):
field_def_num, field_size, base_type_num = self._read_struct(
'3B', endian=endian)
# Try to get field from message type (None if unknown)
field = mesg_type.fields.get(field_def_num) if mesg_type else None
base_type = BASE_TYPES.get(base_type_num, BASE_TYPE_BYTE)
if (field_size % base_type.size) != 0:
# NOTE: we could fall back to byte encoding if there's any
# examples in the wild. For now, just throw an exception
raise FitParseError(
"Invalid field size %d for type '%s' (expected a multiple of %d)"
% (field_size, base_type.name, base_type.size))
# If the field has components that are accumulators
# start recording their accumulation at 0
if field is not None and hasattr(field, 'components'):
if field.components is not None:
for component in field.components:
if component.accumulate:
accumulators = self._accumulators.setdefault(
global_mesg_num, {})
accumulators[component.def_num] = 0
field_defs.append(
FieldDefinition(
field=field,
def_num=field_def_num,
base_type=base_type,
size=field_size,
))
def_mesg = DefinitionMessage(
header=header,
endian=endian,
mesg_type=mesg_type,
mesg_num=global_mesg_num,
field_defs=field_defs,
)
self._local_mesgs[header.local_mesg_num] = def_mesg
return def_mesg
def fit_msg ( local_msg, msg_name, msg_fields, msg_data = None ):
msg_type = [m for m in MESSAGE_TYPES.values() if m.name == msg_name][0]
field_types = []
# Convert msg_fields
for i in range(len(msg_fields)):
if type(msg_fields[i]) != type(()):
msg_fields[i] = (msg_fields[i], None)
# Definition Message
s = struct.pack('<B', 0x40 | local_msg)
s += struct.pack('<xB', 0)
s += struct.pack('<HB', msg_type.mesg_num, len(msg_fields))
for n, sf in msg_fields:
fn = [f for f in msg_type.fields if msg_type.fields[f].name == n][0]
ft = msg_type.fields[fn]
bt = ft.type
if hasattr(bt, 'base_type'):
bt = bt.base_type
if hasattr(ft, 'subfields') and ft.subfields:
sf = [f for f in ft.subfields if f.name == sf][0]
s += struct.pack('<3B', fn, bt.size, bt.identifier)
if sf: ft = sf
field_types.append(ft)
# Data
if msg_data:
for d in msg_data:
s += struct.pack('<B', 0x00 | local_msg)
for fv, ft in zip(d, field_types):
bt = ft.type
if hasattr(bt, 'values') and bt.values:
for v in bt.values:
if bt.values[v] == fv:
fv = v
break
if hasattr(ft, 'offset') and ft.offset:
fv += ft.offset
if hasattr(ft, 'scale') and ft.scale:
fv *= ft.scale
if hasattr(bt, 'base_type'):
bt = bt.base_type
s += struct.pack('<'+bt.fmt, fv)
return s
def fit_msg(local_msg, msg_name, msg_fields, msg_data=None):
msg_type = [m for m in MESSAGE_TYPES.values() if m.name == msg_name][0]
field_types = []
# Convert msg_fields
for i in range(len(msg_fields)):
if type(msg_fields[i]) != type(()):
msg_fields[i] = (msg_fields[i], None)
# Definition Message
s = struct.pack('<B', 0x40 | local_msg)
s += struct.pack('<xB', 0)
s += struct.pack('<HB', msg_type.mesg_num, len(msg_fields))
for n, sf in msg_fields:
fn = [f for f in msg_type.fields if msg_type.fields[f].name == n][0]
ft = msg_type.fields[fn]
bt = ft.type
if hasattr(bt, 'base_type'):
bt = bt.base_type
if hasattr(ft, 'subfields') and ft.subfields:
sf = [f for f in ft.subfields if f.name == sf][0]
s += struct.pack('<3B', fn, bt.size, bt.identifier)
if sf: ft = sf
field_types.append(ft)
# Data
if msg_data:
for d in msg_data:
s += struct.pack('<B', 0x00 | local_msg)
for fv, ft in zip(d, field_types):
bt = ft.type
if hasattr(bt, 'values') and bt.values:
for v in bt.values:
if bt.values[v] == fv:
fv = v
break
if hasattr(ft, 'offset') and ft.offset:
fv += ft.offset
if hasattr(ft, 'scale') and ft.scale:
fv *= ft.scale
if hasattr(bt, 'base_type'):
bt = bt.base_type
s += struct.pack('<' + bt.fmt, fv)
return s
def do_fitparse_profile():
unit_values = []
for message_type in MESSAGE_TYPES.values():
for field in message_type.fields.values():
unit_values.append(field.units)
if field.components:
for component in field.components:
unit_values.append(component.units)
if field.subfields:
for subfield in field.subfields:
unit_values.append(subfield.units)
if subfield.components:
for component in subfield.components:
unit_values.append(component.units)
unit_values = filter(None, unit_values)
print 'In fitparse/profile.py:'
for unit_value in sorted(set(unit_values)):
print ' * %s [%s]' % (
unit_value,
scrub_method_name('process_units_%s' % unit_value, convert_units=True),
)
def do_fitparse_profile():
unit_values = []
for message_type in MESSAGE_TYPES.values():
for field in message_type.fields.values():
unit_values.append(field.units)
if field.components:
for component in field.components:
unit_values.append(component.units)
if field.subfields:
for subfield in field.subfields:
unit_values.append(subfield.units)
if subfield.components:
for component in subfield.components:
unit_values.append(component.units)
unit_values = filter(None, unit_values)
print('In fitparse/profile.py:')
for unit_value in sorted(set(unit_values)):
print(' * {} [{}]'.format(
unit_value,
scrub_method_name('process_units_%s' % unit_value, convert_units=True)
))
