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) ))