fitreader 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8836bb10c48ea552d7ede1a7cfc335fd0928a88
-  data.tar.gz: df87a422072d036bf658a7f0a8fbd8e577b02d44
+  metadata.gz: fa987e945eec8a037f1cd52e0d14ef91f26b72bd
+  data.tar.gz: c22121460e757cff8b7c20145bf06707af7cba47
 SHA512:
-  metadata.gz: 3354ace1a4fd930175ae3d92101db74b596d9ecfd88cee7a89713a20b997676b247071fcb0fdbde5c0adae38d7bd647d93f0037e74b702eaed92aa9ec73ae53c
-  data.tar.gz: 7d95d89756f8e3b30e2bf3f8177165e361dcf178c513e5f69ea84952a7f14d5d73a3e5eb69123d5a2f383a97323aa8cefc958ad7ae844bd8e41c4efc270be5d5
+  metadata.gz: 972d02706d802da6d0965d2379dcae5e0e6326be5206bc55abbb27eb367be4c803faa5cdbc6d22482486baa767e8db69276c3eddbfe1fca89773291c19e24c02
+  data.tar.gz: 2857b1d11a428303e190b658be0770a24c0c78bf3a95a344e3cc0ab33e13c79249eab15988afd1109b64262186b102f38a4f41426fb3f43c9ef7439e337a1f7c

data/.gitignore

@@ -1,9 +1,9 @@
 /.bundle/
 /.yardoc
-/Gemfile.lock
 /_yardoc/
 /coverage/
 /doc/
 /pkg/
 /spec/reports/
 /tmp/
+*.gem

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    fitreader (0.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.1)
+    diff-lcs (1.3)
+    method_source (0.8.2)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.5.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    slop (3.6.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  fitreader!
+  pry (~> 0.10.4)
+  rake (~> 10.0)
+  rspec (~> 3.5)
+
+BUNDLED WITH
+   1.14.6

data/README.md

@@ -35,7 +35,7 @@ require 'fitreader'
 to the class you wish to call it from. After that, it's a simple matter of calling
 
 ```ruby
-Fitreader.read(path_to_fit_file)
+fit_file = Fit.new(path_to_fit_file)
 ```
 
 All of the interface and convenience functions can be found in lib/fitreader.rb.
@@ -43,64 +43,53 @@ All of the interface and convenience functions can be found in lib/fitreader.rb.
 After reading a FIT file, the file header can be inspected by calling
 
 ```ruby
-Fitreader.header
+fit_file.header
 ```
 
 A digest of the records found in the file is shown with
 
 ```ruby
-Fitreader.available_records
+fit_file.digest
 ```
 
-which will return a list similar to the following, showing respectively the global_message_number (as defined in the FIT SDK), the name of the record type, and the number of records parsed
+which will return a list similar to the following, showing respectively the name of the record type (as defined in the FIT SDK), and the number of records parsed
 
 ```ruby
-[[0, :file_id, 1],
- [3, :user_profile, 1],
- [7, :zones_target, 1],
- [18, :session, 1],
- [19, :lap, 1],
- [20, :record, 2899],
- [21, :event, 73],
- [22, :source, 58],
- [23, :device_info, 14],
- [34, :activity, 1],
- [49, :file_creator, 1],
- [72, :training_file, 1],
- [104, :battery_info, 40],
- [147, :sensor_info, 3]]
+{:file_id=>1,
+ :file_creator=>1,
+ :device_settings=>1,
+ :user_profile=>1,
+ :sensor_info=>5,
+ :sport=>1,
+ :zones_target=>1,
+ :record=>4988,
+ :event=>120,
+ :device_info=>30,
+ :source=>43,
+ :segment_lap=>2,
+ :lap=>1,
+ :session=>1,
+ :activity=>1,
+ :battery_info=>20}
 ```
 
 Armed with this information, we can call
 
 ```ruby
-Fitreader.get_message_type filter
+fit_file.type <name>
 ```
 
-where filter is either the global_number or the name supplied by the previous command, for example
+where <name> is the name supplied by the previous command, for example
 
 ```ruby
-Fitreader.get_message_type 18
-Fitreader.get_message_type :session
+fit_file.type :session
 ```
 
-will both fetch the session record(s) in the form of a MessageType object. This object contains three fields: a definition, an array of records and an array of undefined_records.
+will fetch the session record(s) in the form of a Message object. This object contains three fields: a name, a global_num (as defined by the FIT SDK), and an array of records.
 
-The definition contains metadata from a combination of the FIT file itself and the SKD. I will write more detailed information, but basically this information tells us how to interpret the actual data. Of most relevance, it tells us the name and datatype of each field we will find in records of this type.
-
-The records array contains a list or Record objects. A Record object contains a fields array and an error_fields array. The fields array is a list of the actual data contined within this record, for example timestamp, or coordinated, etc. The particular FieldData object includes the name of the field (also found in the definition), along with the raw_value and the processed value which may differ in the case of, for example, a coordinate.
-
-The error_fields array contains any fields defined in the FIT file itself that aren't defined within the SDK. Without the SKD we can most likely never know what the field represents or whether the raw value would need further processing to make sense to us. These are included mostly for debugging and future convenience sake.
-
-The results of this function are probably a lot more data that we generally need, so a convenience function is included that distills the results of the previous call into a more efficient dataset
-
-```ruby
-Fitreader.record_values 20
-Fitreader.record_values :record
-```
-
-This will return an array of hashes, one hash for each record of the specified type. The hashes contain only the field name and value, for example
+The records array contains a list of hashes, with key-value pairs of field name (also according to the message-type definition) and value, for example timestamp, or coordinates, etc.
 
+For example:
 ```ruby
 {:timestamp=>2016-04-09 11:19:51 UTC,
  :position_lat=>57.711100755259395,
@@ -116,7 +105,7 @@ This will return an array of hashes, one hash for each record of the specified t
 
  Some things to watch out for:
 
- - speed is recorded as m/s in my files, rather than kph as one might expect.
+ - speed is recorded as m/s, rather than kph as one might expect.
 
 ## Development
 

data/fitreader.gemspec

@@ -31,7 +31,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.5"
-  spec.add_development_dependency "pry"
-
-  # spec.add_dependency('bindata')
+  spec.add_development_dependency "pry", '~> 0.10.4'
 end

data/lib/fitreader.rb

@@ -1,55 +1,5 @@
-require 'fitreader/fitfile'
-require 'fitreader/version'
-require 'fitreader/static'
-
 module Fitreader
-  def self.read(path)
-    @f = FitFile.new(path)
-  end
-
-  def self.header
-    @f.header
-  end
-
-  def self.available_records
-    @f.messages
-      .select { |_,v| !v.any? { |z| z.definition.name.nil? } }
-      .select { |_,v| !v.any? { |z| z.records.length.zero? } }
-      .collect { |x| [x[0], x[1].first.definition.name, x[1].collect(&:records).flatten.length] }
-      .sort
-  end
-
-  def self.get_message_type(filter)
-    if filter.is_a?(Symbol)
-      res = @f.messages.find { |_,y| y.any? { |z| z.definition.name == filter } }
-      res[1] unless res.nil?
-    elsif filter.is_a?(Integer)
-      @f.messages[filter]
-    else
-      raise ArgumentError, 'needs a string or a symbol'
-    end
-  end
-
-  def self.record_values(filter)
-    message = get_message_type filter
-    message.collect(&:record_values).flatten
-  end
-
-  def self.error_messages
-    @f.messages.select { |_, v| !v.any? { |x| x.undefined_records.empty? } }
-  end
-
-  def self.error_fields(filter)
-    message = get_message_type filter
-    message.collect(&:error_fields).flatten
-  end
-
-  # def self.filter_by_scope(filter)
-  #   valid = Static.scope.include? filter
-  #   unless valid
-  #     @f.records.select { |x| x.type == filter }
-  #   else
-  #     puts "invalid scope, must be one of #{Static.scope}"
-  #   end
-  # end
 end
+
+require 'fitreader/fit'
+require 'fitreader/version'

data/lib/fitreader/data_field.rb

@@ -0,0 +1,38 @@
+class DataField < FitObject
+  TYPES = {
+    0 => { size: 1, unpack_type: 'C', endian: 0, invalid: 255 },
+    1 => { size: 1, unpack_type: 'c', endian: 0, invalid: 127 },
+    2 => { size: 1, unpack_type: 'C', endian: 0, invalid: 255 },
+    3 => { size: 2, unpack_type: { big: 's>', little: 's<' }, endian: 1, invalid: 32767 },
+    4 => { size: 2, unpack_type: { big: 'S>', little: 'S<' }, endian: 1, invalid: 65535 },
+    5 => { size: 4, unpack_type: { big: 'l>', little: 'l<' }, endian: 1, invalid: 2147483647 },
+    6 => { size: 4, unpack_type: { big: 'L>', little: 'L<' }, endian: 1, invalid: 4294967295 },
+    7 => { size: 1, unpack_type: 'Z*', endian: 0, invalid: 0 },
+    8 => { size: 4, unpack_type: { big: 'e', little: 'g' }, endian: 1, invalid: 4294967295 },
+    9 => { size: 8, unpack_type: { big: 'E', little: 'G' }, endian: 1, invalid: 18446744073709551615 },
+    10 => { size: 1, unpack_type: 'C', endian: 0, invalid: 0 },
+    11 => { size: 2, unpack_type: { big: 'S>', little: 'S<' }, endian: 1, invalid: 0 },
+    12 => { size: 4, unpack_type: { big: 'L>', little: 'L<' }, endian: 1, invalid: 0 },
+    13 => { size: 1, unpack_type: 'C', endian: 0, invalid: 0xFF },
+    14 => { size: 8, unpack_type: { big: 'q>', little: 'q<' }, endian: 1, invalid: 0x7FFFFFFFFFFFFFFF },
+    15 => { size: 8, unpack_type: { big: 'Q>', little: 'Q<' }, endian: 1, invalid: 0xFFFFFFFFFFFFFFFF },
+    16 => { size: 8, unpack_type: nil, endian: 1, invalid: 0x0000000000000000 }
+  }.freeze
+
+  attr_reader :raw, :valid
+
+  def initialize(io, d, arch)
+    base = TYPES[d.base_num]
+    char = d.endianness.zero? ? base[:unpack_type] : base[:unpack_type][arch]
+    @raw = read_multiple(io, char, d.size, base[:size])
+    @valid = check(@raw, base[:invalid])
+  end
+
+  def check(raw, invalid)
+    if raw.is_a? Array
+      raw.any? { |e| e != invalid }
+    else
+      raw != invalid
+    end
+  end
+end

data/lib/fitreader/data_record.rb

@@ -0,0 +1,14 @@
+class DataRecord < FitObject
+  attr_reader :fields, :global_num
+
+  def initialize(io, definition)
+    @global_num = definition.global_msg_num
+    @fields = Hash[definition.field_definitions.map do |f|
+      [f.field_def_num, DataField.new(io, f, definition.endian)]
+    end]
+  end
+
+  def valid
+    @fields.select { |_, v| v.valid }
+  end
+end

data/lib/fitreader/definition_record.rb

@@ -0,0 +1,28 @@
+require_relative 'field_definition.rb'
+
+class DefinitionRecord < FitObject
+  attr_reader :reserved, :architecture, :global_msg_num, :num_fields, :field_definitions, :data_records, :local_num
+
+  def initialize(io, local_num)
+    @local_num = local_num
+    @reserved = io.readbyte
+    @architecture = io.readbyte
+    char = @architecture.zero? ? 'v' : 'n'
+    @global_msg_num = readbytes(io, char, 2)
+    @num_fields = io.readbyte
+    @field_definitions = Array.new(num_fields) { FieldDefinition.new(io) }
+    @data_records = []
+  end
+
+  def endian
+    @architecture.zero? ? :little : :big
+  end
+
+  def valid
+    fd = Sdk.fields(@global_msg_num)
+    return if fd.nil?
+    @data_records.map do |d|
+      d.valid.select { |k, _| fd.keys.include? k }
+    end
+  end
+end

data/lib/fitreader/field_definition.rb

@@ -1,15 +1,11 @@
-module Fitreader
-  class FieldDefinition
-    attr_accessor :def_num, :size, :base_num
+class FieldDefinition < FitObject
+  attr_reader :field_def_num, :size, :endianness, :base_num
 
-    def initialize(msg_num, bytes)
-      @def_num = bytes[0].unpack('C').first
-      @size = bytes[1].unpack('C').first
-      # @single_byte = bytes[2].unpack('C').first & ENDIAN_ABILITY == 0
-      @base_num = bytes[2].unpack('C').first & BASE_TYPE_NUM
-    end
-
-    ENDIAN_ABILITY = 128
-    BASE_TYPE_NUM = 31
+  def initialize(io)
+    @field_def_num = io.readbyte
+    @size = io.readbyte
+    byte = io.readbyte
+    @endianness = read_bit(byte, 7)
+    @base_num = read_bits(byte, 4..0)
   end
 end

data/lib/fitreader/file_header.rb

@@ -1,17 +1,12 @@
-class FileHeader
-  attr_accessor :header_size, :protocol_version,
-  :profile_version, :num_records, :valid_file, :crc
+class FileHeader < FitObject
+  attr_accessor :header_size, :protocol_version, :profile_version, :num_record_bytes, :valid_file, :crc
 
-  def initialize(bytes)
-    @header_size = bytes[0].unpack('C').first
-    @protocol_version = bytes[1].unpack('C').first
-    @profile_version = bytes[2..3].unpack('v').first
-    @num_records = bytes[4..7].unpack('V').first
-    @valid_file = bytes[8..11] == ".FIT"
-    @crc = bytes[12..13].unpack('v').first
-  end
-
-  def to_s
-    "size: #{header_size}, proto_v: #{protocol_version}, prof_v: #{profile_version}, records: #{num_records}"
+  def initialize(io)
+    @header_size = io.readbyte
+    @protocol_version = io.readbyte
+    @profile_version = readbytes(io, 'v', 2)
+    @num_record_bytes = readbytes(io, 'V', 4)
+    @valid_file = io.read(4) == '.FIT'
+    @crc = readbytes(io, 'v', 2)
   end
 end

data/lib/fitreader/fit.rb

@@ -0,0 +1,49 @@
+require_relative 'unpack.rb'
+require_relative 'fit_object.rb'
+require_relative 'file_header.rb'
+require_relative 'record_header.rb'
+require_relative 'definition_record.rb'
+require_relative 'data_field.rb'
+require_relative 'data_record.rb'
+require_relative 'message.rb'
+require_relative 'sdk/sdk.rb'
+
+class Fit
+  attr_reader :header, :messages
+
+  def initialize(io)
+    @header = FileHeader.new(io)
+    finished = []
+    begin
+      defs = {}
+      until io.pos >= header.num_record_bytes
+        h = RecordHeader.new(io)
+        if h.definition?
+          d = DefinitionRecord.new(io, h.local_message_type)
+          finished << defs[d.local_num] if defs.key? d.local_num
+          defs[d.local_num] = d
+        elsif h.data?
+          d = defs[h.local_message_type] if d.local_num != h.local_message_type
+          d.data_records << DataRecord.new(io, d)
+        else
+          # TODO implement timestamps
+        end
+      end
+      finished.push(*defs.values)
+    rescue
+      puts "error"
+    end
+    io.close
+    @messages = finished.group_by(&:global_msg_num)
+                        .map { |x| Message.new x }
+                        .reject { |x| x.data.nil? }
+  end
+
+  def digest
+    Hash[@messages.map { |x| [x.name, x.data.count] }]
+  end
+
+  def type(name)
+    messages.find { |x| x.name == name }
+  end
+end

data/lib/fitreader/fit_object.rb

@@ -0,0 +1,8 @@
+require 'ostruct'
+class FitObject
+  include Unpack
+
+  def to_h
+    @data.to_h
+  end
+end

data/lib/fitreader/message.rb

@@ -0,0 +1,82 @@
+class Message
+  attr_accessor :global_num, :name, :data
+
+  def initialize(definitions)
+    @global_num = definitions[0]
+    @name = Sdk.message(@global_num)
+    return unless @name
+
+    fd = Sdk.fields(@global_num)
+    @data = definitions[1].map { |x| make_message(x, fd) }.flatten
+  end
+
+  private
+
+  def make_message(definition, fields)
+    return if definition.valid.nil?
+    definition.valid.map do |d|
+      h = Hash[d.map { |k, v| process_value(fields[k], v.raw) }]
+      case @global_num
+      when 21
+        h = process_event(h)
+      when 0, 23
+        h = process_deviceinfo(h)
+      end
+      h
+    end
+  end
+
+  def process_value(type, val)
+    if type[:type][0..3].to_sym == :enum
+      val = Sdk.enum(type[:type])[val]
+    elsif type[:type] == :date_time
+      t = Time.new(1989, 12, 31, 0, 0, 0, '+00:00').utc.to_i
+      Time.at(val + t).utc
+    elsif type[:type] == :local_date_time
+      t = Time.new(1989, 12, 31, 0, 0, 0, '+02:00').utc.to_i
+      val = Time.at(val + t)
+    elsif type[:type] == :coordinates
+      val *= (180.0 / 2**31)
+    end
+
+    unless type[:scale].zero?
+      if val.is_a? Array
+        val = val.map { |x| (x * 1.0) / type[:scale] }
+      else
+        val = (val * 1.0) / type[:scale]
+      end
+    end
+
+    unless type[:offset].zero?
+      if val.is_a? Array
+        val.map { |x| x - type[:offset] }
+      else
+        val - type[:offset]
+      end
+    end
+    [type[:name], val]
+  rescue => e
+    puts e
+  end
+
+  def process_event(h)
+    case h[:event]
+    when :rear_gear_change, :front_gear_change
+      h[:data] = h[:data].pack('V*').unpack('C*')
+    end
+    h
+  end
+
+  def process_deviceinfo(h)
+    case h[:source_type]
+    when :antplus
+      h[:device_type] = Sdk.enum(:antplus_device_type)[h[:value]]
+    end
+
+    case h[:manufacturer]
+    when :garmin, :dynastream, :dynastream_oem
+      h[:garmin_product] = Sdk.enum(:enum_garmin_product)[h[:garmin_product]]
+    end
+    h
+  end
+end