fit4ruby 0.0.1

data/lib/fit4ruby/Converters.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Converters.rb -- Fit4Ruby - FIT file processing library for Ruby
+#
+# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+module Fit4Ruby
+
+  module Converters
+
+    def speedToPace(speed)
+      if speed > 0.01
+        pace = 1000.0 / (speed * 60.0)
+        int, dec = pace.divmod 1
+        "#{int}:#{'%02d' % (dec * 60)}"
+      else
+        "-:--"
+      end
+    end
+
+    def secsToHMS(secs)
+      secs = secs.to_i
+      s = secs % 60
+      mins = secs / 60
+      m = mins % 60
+      h = mins / 60
+      "#{h}:#{'%02d' % m}:#{'%02d' % s}"
+    end
+
+    def secsToDHMS(secs)
+      secs = secs.to_i
+      s = secs % 60
+      mins = secs / 60
+      m = mins % 60
+      hours = mins / 60
+      h = hours % 24
+      d = hours / 24
+      "#{d} days #{h}:#{'%02d' % m}:#{'%02d' % s}"
+    end
+
+    def time_to_fit_time(t)
+      (t - Time.parse('1989-12-31')).to_i
+    end
+
+    def fit_time_to_time(ft)
+      Time.parse('1989-12-31') + ft.to_i
+    end
+
+  end
+
+end
+

data/lib/fit4ruby/FitDataRecord.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FitDataRecord.rb -- Fit4Ruby - FIT file processing library for Ruby
+#
+# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'fit4ruby/FitMessageIdMapper'
+require 'fit4ruby/GlobalFitMessages.rb'
+
+module Fit4Ruby
+
+  class FitDataRecord
+
+    def initialize(record_id)
+      @message = GlobalFitMessages.find_by_name(record_id)
+      @renames = {}
+    end
+
+    def rename(fit_var, var)
+      @renames[fit_var] = var
+    end
+
+    def write(io, id_mapper)
+      global_message_number = @message.number
+
+      # Map the global message number to the current local message number.
+      unless (local_message_number = id_mapper.get_local(global_message_number))
+        # If the current dictionary does not contain the global message
+        # number, we need to create a new entry for it. The index in the
+        # dictionary is the local message number.
+        local_message_number = id_mapper.add_global(global_message_number)
+        # Write the definition of the global message number to the file.
+        @message.write(io, local_message_number)
+      end
+
+      # Write data record header.
+      header = FitRecordHeader.new
+      header.normal = 0
+      header.message_type = 0
+      header.local_message_type = local_message_number
+      header.write(io)
+
+      # Create a BinData::Struct object to store the data record.
+      fields = []
+      @message.fields.each do |field_number, field|
+        bin_data_type = FitDefinitionField.fit_type_to_bin_data(field.type)
+        fields << [ bin_data_type, field.name ]
+      end
+      bd = BinData::Struct.new(:endian => :little, :fields => fields)
+
+      # Fill the BinData::Struct object with the values from the corresponding
+      # instance variables.
+      @message.fields.each do |field_number, field|
+        iv = "@#{@renames[field.name] || field.name}"
+        if instance_variable_defined?(iv) &&
+           !(iv_value = instance_variable_get(iv)).nil?
+          value = field.native_to_fit(iv_value)
+        else
+          # If we don't have a corresponding variable or the variable is nil
+          # we write the 'undefined' value instead.
+          value = FitDefinitionField.undefined_value(field.type)
+        end
+        bd[field.name] = value
+      end
+
+      # Write the data record to the file.
+      bd.write(io)
+    end
+
+  end
+
+end
+

data/lib/fit4ruby/FitDefinition.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FitDefinition.rb -- Fit4Ruby - FIT file processing library for Ruby
+#
+# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'bindata'
+require 'fit4ruby/FitDefinitionField'
+
+module Fit4Ruby
+
+  class FitDefinition < BinData::Record
+
+    hide :reserved
+
+    uint8 :reserved, :initial_value => 0
+    uint8 :architecture, :initial_value => 0
+    choice :global_message_number, :selection => :architecture do
+      uint16le 0
+      uint16be :default
+    end
+    uint8 :field_count
+    array :fields, :type => FitDefinitionField, :initial_length => :field_count
+
+    def endian
+      architecture.snapshot == 0 ? :little : :big
+    end
+
+    def check
+      fields.each { |f| f.check }
+    end
+
+    def setup(fit_message_definition)
+      fit_message_definition.fields.each do |number, f|
+        fdf = FitDefinitionField.new
+        fdf.field_definition_number = number
+        fdf.set_type(f.type)
+
+        fields << fdf
+      end
+      self.field_count = fields.length
+    end
+
+  end
+
+
+end
+

data/lib/fit4ruby/FitDefinitionField.rb

@@ -0,0 +1,137 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FitDefinitionField.rb -- Fit4Ruby - FIT file processing library for Ruby
+#
+# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'bindata'
+require 'time'
+require 'fit4ruby/Log'
+require 'fit4ruby/GlobalFitMessage'
+
+module Fit4Ruby
+
+  class FitDefinitionField < BinData::Record
+
+    @@TypeDefs = [
+      # FIT Type, BinData type, undefined value, bytes
+      [ 'enum', 'uint8', 0xFF, 1 ],
+      [ 'sint8', 'int8', 0x7F, 1 ],
+      [ 'uint8', 'uint8', 0xFF, 1 ],
+      [ 'sint16', 'int16', 0x7FFF, 2 ],
+      [ 'uint16', 'uint16', 0xFFFF, 2 ],
+      [ 'sint32', 'int32', 0x7FFFFFFF, 4 ],
+      [ 'uint32', 'uint32', 0xFFFFFFFF, 4 ],
+      [ 'string', 'stringz', '', 0 ],
+      [ 'float32', 'float', 0xFFFFFFFF, 4 ],
+      [ 'float63', 'double', 0xFFFFFFFF, 4 ],
+      [ 'uint8z', 'uint8', 0, 1 ],
+      [ 'uint16z', 'uint16', 0, 2 ],
+      [ 'uint32z', 'uint32', 0, 4 ],
+      [ 'byte', 'uint8', 0xFF, 1 ]
+    ]
+
+    hide :reserved
+
+    uint8 :field_definition_number
+    uint8 :byte_count
+    bit1 :endian_ability
+    bit2 :reserved
+    bit5 :base_type_number
+
+    def self.fit_type_to_bin_data(fit_type)
+      entry = @@TypeDefs.find { |e| e[0] == fit_type }
+      raise "Unknown fit type #{fit_type}" unless entry
+      entry[1]
+    end
+
+    def self.undefined_value(fit_type)
+      entry = @@TypeDefs.find { |e| e[0] == fit_type }
+      raise "Unknown fit type #{fit_type}" unless entry
+      entry[2]
+    end
+
+    def init
+      @global_message_number = parent.parent.global_message_number.snapshot
+      @global_message_definition = GlobalFitMessages[@global_message_number]
+      field_number = field_definition_number.snapshot
+      if @global_message_definition &&
+         (field = @global_message_definition.fields[field_number])
+         @name = field.name
+         @type = field.type
+
+         if @type && (td = @@TypeDefs[base_type_number]) && td[0] != @type
+           Log.warn "#{@global_message_number}:#{@name} must be of type " +
+           "#{@type}, not #{td[0]}"
+         end
+      else
+        @name = "field#{field_definition_number.snapshot}"
+        @type = nil
+        Log.warn { "Unknown field number #{field_definition_number} " +
+                   "in global message #{@global_message_number}" }
+      end
+    end
+
+    def name
+      init unless @global_message_number
+      @name
+    end
+
+    def to_machine(value)
+      init unless @global_message_number
+      value = nil if value == undefined_value
+
+      field_number = field_definition_number.snapshot
+      if @global_message_definition &&
+         (field = @global_message_definition.fields[field_number])
+        field.to_machine(value)
+      else
+        value
+      end
+    end
+
+    def to_s(value)
+      init unless @global_message_number
+      value = nil if value == undefined_value
+
+      field_number = field_definition_number.snapshot
+      if @global_message_definition &&
+         (field = @global_message_definition.fields[field_number])
+        field.to_s(value)
+      else
+        "[#{value.to_s}]"
+      end
+    end
+
+    def set_type(fit_type)
+      idx = @@TypeDefs.index { |x| x[0] == fit_type }
+      raise "Unknown type #{fit_type}" unless idx
+      self.base_type_number = idx
+      self.byte_count = @@TypeDefs[idx][3]
+    end
+
+    def type(fit_type = false)
+      if @@TypeDefs.length <= base_type_number.snapshot
+        Log.fatal "Unknown FIT Base type #{base_type_number.snapshot}"
+      end
+
+      @@TypeDefs[base_type_number.snapshot][fit_type ? 0 : 1]
+    end
+
+    def undefined_value
+      if @@TypeDefs.length <= base_type_number.snapshot
+        Log.fatal "Unknown FIT Base type #{base_type_number.snapshot}"
+      end
+
+      @@TypeDefs[base_type_number.snapshot][2]
+    end
+
+  end
+
+end

data/lib/fit4ruby/FitFile.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = FitFile.rb -- Fit4Ruby - FIT file processing library for Ruby
+#
+# Copyright (c) 2014 by Chris Schlaeger <cs@taskjuggler.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'fit4ruby/Log'
+require 'fit4ruby/FitHeader'
+require 'fit4ruby/FitRecord'
+require 'fit4ruby/FitFilter'
+require 'fit4ruby/FitMessageIdMapper'
+require 'fit4ruby/FitFileId'
+require 'fit4ruby/GlobalFitMessages'
+require 'fit4ruby/GlobalFitDictionaries'
+
+module Fit4Ruby
+
+  class FitFile
+
+    def initialize()
+      @header = nil
+    end
+
+    def read(file_name, filter = nil)
+      @file_name = file_name
+      definitions = {}
+      begin
+        io = ::File.open(file_name, 'rb')
+      rescue RuntimeError => e
+        Log.critical("Cannot open FIT file '#{file_name}'", e)
+      end
+      header = FitHeader.read(io)
+      header.check
+
+      check_crc(io, header.end_pos)
+
+      activity = Activity.new
+      # This Array holds the raw data of the records that may be needed to
+      # dump a human readable form of the FIT file.
+      records = []
+      # This hash will hold a counter for each record type. The counter is
+      # incremented each time the corresponding record type is found.
+      record_counters = Hash.new { 0 }
+      while io.pos < header.end_pos
+        record = FitRecord.new(definitions)
+        record.read(io, activity, filter, record_counters)
+        records << record if filter
+      end
+
+      io.close
+
+      header.dump if filter && filter.record_numbers.nil?
+      dump_records(records) if filter
+
+      activity.check
+      activity
+    end
+
+    def write(file_name, activity)
+      begin
+        io = ::File.open(file_name, 'wb+')
+      rescue StandardError => e
+        Log.critical("Cannot open FIT file '#{file_name}'", e)
+      end
+
+      # Create a header object, but don't yet write it into the file.
+      header = FitHeader.new
+      start_pos = header.header_size
+      # Move the pointer behind the header section.
+      io.seek(start_pos)
+      id_mapper = FitMessageIdMapper.new
+      FitFileId.new.write(io, id_mapper)
+      activity.write(io, id_mapper)
+      end_pos = io.pos
+
+      crc = write_crc(io, start_pos, end_pos)
+
+      # Complete the data of the header section and write it at the start of
+      # the file.
+      header.data_size = end_pos - start_pos
+      header.crc = crc
+      io.seek(0)
+      header.write(io)
+
+      io.close
+    end
+
+    private
+
+    def check_crc(io, end_pos)
+      # Save the current file IO position
+      start_pos = io.pos
+
+      crc = compute_crc(io, start_pos, end_pos)
+
+      # Read the 2 CRC bytes from the end of the file
+      io.seek(-2, IO::SEEK_END)
+      crc_ref = io.readbyte.to_i | (io.readbyte.to_i << 8)
+      io.seek(start_pos)
+
+      unless crc == crc_ref
+        Log.critical "Checksum error in file '#{@file_name}'. " +
+                     "Computed #{"%04X" % crc} instead of #{"%04X" % crc_ref}."
+      end
+    end
+
+    def write_crc(io, start_pos, end_pos)
+      # Compute the checksum over the data section of the file and append it
+      # to the file. Ideally, we should compute the CRC from data in memory
+      # instead of the file data.
+      crc = compute_crc(io, start_pos, end_pos)
+      io.seek(end_pos)
+      BinData::Uint16le.new(crc).write(io)
+
+      crc
+    end
+
+    def compute_crc(io, start_pos, end_pos)
+      crc_table = [
+        0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401,
+        0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400
+      ]
+
+      io.seek(start_pos)
+
+      crc = 0
+      while io.pos < end_pos
+        byte = io.readbyte
+
+        0.upto(1) do |i|
+          tmp = crc_table[crc & 0xF]
+          crc = (crc >> 4) & 0x0FFF
+          crc = crc ^ tmp ^ crc_table[(byte >> (4 * i)) & 0xF]
+        end
+      end
+
+      crc
+    end
+
+    def dump_records(records)
+      records.each do |record|
+        record.dump
+      end
+    end
+
+  end
+
+end