openc3 5.0.6

data/lib/openc3/conversions/generic_conversion.rb

@@ -0,0 +1,83 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+require 'openc3/packets/binary_accessor'
+
+module OpenC3
+  # Performs a generic conversion by evaluating Ruby code
+  class GenericConversion < Conversion
+    # @return [String] The Ruby code to evaluate which should return the
+    #   converted value
+    attr_accessor :code_to_eval
+
+    # @param code_to_eval [String] The Ruby code to evaluate which should
+    #   return the converted value
+    # @param converted_type [Symbol] The converted data type. Must be one of
+    #   {BinaryAccessor::DATA_TYPES}
+    # @param converted_bit_size [Integer] The size in bits of the converted
+    #   value
+    # @param converted_array_size [Integer] The size in bits of the converted array
+    #   value (full size of all items if array)
+    def initialize(code_to_eval, converted_type = nil, converted_bit_size = nil, converted_array_size = nil)
+      super()
+      @code_to_eval = code_to_eval
+      if ConfigParser.handle_nil(converted_type)
+        converted_type = converted_type.to_s.upcase.intern
+        raise "Invalid type #{converted_type}" unless BinaryAccessor::DATA_TYPES.include?(converted_type)
+
+        @converted_type = converted_type
+      end
+      @converted_bit_size = Integer(converted_bit_size) if ConfigParser.handle_nil(converted_bit_size)
+      @converted_array_size = Integer(converted_array_size) if ConfigParser.handle_nil(converted_array_size)
+    end
+
+    # (see OpenC3::Conversion#call)
+    def call(value, packet, buffer)
+      myself = packet # For backwards compatibility
+      if true or myself # Remove unused variable warning for myself
+        return eval(@code_to_eval)
+      end
+    end
+
+    # @return [String] The conversion class followed by the code to evaluate
+    def to_s
+      "#{@code_to_eval}"
+    end
+
+    # @param (see Conversion#to_config)
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      config = "    GENERIC_#{read_or_write}_CONVERSION_START"
+      config << " #{@converted_type}" if @converted_type
+      config << " #{@converted_bit_size}" if @converted_bit_size
+      config << " #{@converted_array_size}" if @converted_array_size
+      config << "\n"
+      config << @code_to_eval
+      config << "    GENERIC_#{read_or_write}_CONVERSION_END\n"
+      config
+    end
+
+    def as_json(*a)
+      result = super(*a)
+      result['params'] = [@code_to_eval, @converted_type, @converted_bit_size, @converted_array_size]
+      result
+    end
+  end
+end

data/lib/openc3/conversions/packet_time_formatted_conversion.rb

@@ -0,0 +1,43 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Converts the packet received time object into a formatted string.
+  class PacketTimeFormattedConversion < Conversion
+    # Initializes converted_type to :STRING and converted_bit_size to 0
+    def initialize
+      super()
+      @converted_type = :STRING
+      @converted_bit_size = 0
+    end
+
+    # @param (see Conversion#call)
+    # @return [String] Formatted packet time
+    def call(value, packet, buffer)
+      packet_time = packet.packet_time
+      if packet_time
+        return packet_time.formatted
+      else
+        return 'No Packet Time'
+      end
+    end
+  end # class PacketTimeFormattedConversion
+end

data/lib/openc3/conversions/packet_time_seconds_conversion.rb

@@ -0,0 +1,43 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Converts the packet received time into floating point seconds.
+  class PacketTimeSecondsConversion < Conversion
+    # Initializes converted_type to :FLOAT and converted_bit_size to 64
+    def initialize
+      super()
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] Packet received time in seconds
+    def call(value, packet, buffer)
+      packet_time = packet.packet_time
+      if packet_time
+        return packet_time.to_f
+      else
+        return 0.0
+      end
+    end
+  end # class PacketTimeSecondsConversion
+end

data/lib/openc3/conversions/polynomial_conversion.rb

@@ -0,0 +1,87 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+require 'openc3/ext/polynomial_conversion' if RUBY_ENGINE == 'ruby' and !ENV['OPENC3_NO_EXT']
+
+module OpenC3
+  # Performs a polynomial conversion on the value
+  class PolynomialConversion < Conversion
+    # @return [Array<Float>] The polynomial coefficients
+    attr_accessor :coeffs
+
+    # Initializes the conversion with the given polynomial coefficients. Sets
+    # the converted_type to :FLOAT and the converted_bit_size to 64.
+    #
+    # @param coeffs [Array<Float>] The polynomial coefficients
+    def initialize(*coeffs)
+      super()
+      @coeffs = coeffs.map { |coeff| coeff.to_f }
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    if RUBY_ENGINE != 'ruby' or ENV['OPENC3_NO_EXT']
+      # @param (see Conversion#call)
+      # @return [Float] The value with the polynomial applied
+      def call(value, myself, buffer)
+        value = value.to_f
+
+        # Handle C0
+        result = @coeffs[0]
+
+        # Handle Coefficients raised to a power
+        raised_to_power = 1.0
+        @coeffs[1..-1].each do |coeff|
+          raised_to_power *= value
+          result += (coeff * raised_to_power)
+        end
+
+        return result
+      end
+    end
+
+    # @return [String] Class followed by the list of coefficients
+    def to_s
+      result = ""
+      @coeffs.length.times do |index|
+        if index == 0
+          result << "#{@coeffs[index]}"
+        elsif index == 1
+          result << " + #{@coeffs[index]}x"
+        else
+          result << " + #{@coeffs[index]}x^#{index}"
+        end
+      end
+      result
+    end
+
+    # @param (see Conversion#to_config)
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      "    POLY_#{read_or_write}_CONVERSION #{@coeffs.join(' ')}\n"
+    end
+
+    def as_json(*a)
+      result = super(*a)
+      result['params'] = @coeffs
+      result
+    end
+  end
+end

data/lib/openc3/conversions/processor_conversion.rb

@@ -0,0 +1,70 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Retrieves the result from an item processor
+  class ProcessorConversion < Conversion
+    # @param processor_name [String] The name of the associated processor
+    # @param result_name [String] The name of the associated result in the processor
+    # @param converted_type [String or nil] The datatype of the result of the processor
+    # @param converted_bit_size [Integer or nil] The bit size of the result of the processor
+    # @param converted_array_size [Integer or nil] The total array bit size of the result of the processor
+    def initialize(processor_name, result_name, converted_type = nil, converted_bit_size = nil, converted_array_size = nil)
+      super()
+      @processor_name = processor_name.to_s.upcase
+      @result_name = result_name.to_s.upcase.intern
+      if ConfigParser.handle_nil(converted_type)
+        @converted_type = converted_type.to_s.upcase.intern
+        raise ArgumentError, "Unknown converted type: #{converted_type}" if !BinaryAccessor::DATA_TYPES.include?(@converted_type)
+      end
+      @converted_bit_size = Integer(converted_bit_size) if ConfigParser.handle_nil(converted_bit_size)
+      @converted_array_size = Integer(converted_array_size) if ConfigParser.handle_nil(converted_array_size)
+    end
+
+    # @param (see Conversion#call)
+    # @return [Varies] The result of the associated processor
+    def call(value, packet, buffer)
+      packet.processors[@processor_name].results[@result_name] || 0 # Never return nil
+    end
+
+    # @return [String] The type of processor
+    def to_s
+      "ProcessorConversion #{@processor_name} #{@result_name}"
+    end
+
+    # @param (see Conversion#to_config)
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      config = "    #{read_or_write}_CONVERSION #{self.class.name.class_name_to_filename} #{@processor_name} #{@result_name}"
+      config << " #{@converted_type}" if @converted_type
+      config << " #{@converted_bit_size}" if @converted_bit_size
+      config << " #{@converted_array_size}" if @converted_array_size
+      config << "\n"
+      config
+    end
+
+    def as_json(*a)
+      result = super(*a)
+      result['params'] = [@processor_name, @result_name, @converted_type, @converted_bit_size, @converted_array_size]
+      result
+    end
+  end # class ProcessorConversion
+end

data/lib/openc3/conversions/received_count_conversion.rb

@@ -0,0 +1,38 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Converts the packet received count as a derived telemetry item
+  class ReceivedCountConversion < Conversion
+    # Initializes converted_type to :UINT and converted_bit_size to 32
+    def initialize
+      super()
+      @converted_type = :UINT
+      @converted_bit_size = 32
+    end
+
+    # @param (see Conversion#call)
+    # @return [Integer] packet.received_count
+    def call(value, packet, buffer)
+      packet.received_count
+    end
+  end # class ReceivedCountConversion
+end

data/lib/openc3/conversions/received_time_formatted_conversion.rb

@@ -0,0 +1,42 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Converts the packet received time object into a formatted string.
+  class ReceivedTimeFormattedConversion < Conversion
+    # Initializes converted_type to :STRING and converted_bit_size to 0
+    def initialize
+      super()
+      @converted_type = :STRING
+      @converted_bit_size = 0
+    end
+
+    # @param (see Conversion#call)
+    # @return [String] Formatted packet time
+    def call(value, packet, buffer)
+      if packet.received_time
+        return packet.received_time.formatted
+      else
+        return 'No Packet Received Time'
+      end
+    end
+  end # class ReceivedTimeFormattedConversion
+end

data/lib/openc3/conversions/received_time_seconds_conversion.rb

@@ -0,0 +1,42 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Converts the packet received time into floating point seconds.
+  class ReceivedTimeSecondsConversion < Conversion
+    # Initializes converted_type to :FLOAT and converted_bit_size to 64
+    def initialize
+      super()
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] Packet received time in seconds
+    def call(value, packet, buffer)
+      if packet.received_time
+        return packet.received_time.to_f
+      else
+        return 0.0
+      end
+    end
+  end # class ReceivedTimeSecondsConversion
+end

data/lib/openc3/conversions/segmented_polynomial_conversion.rb

@@ -0,0 +1,171 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Segmented polynomial conversions consist of polynomial conversions that are
+  # applied for a range of values.
+  class SegmentedPolynomialConversion < Conversion
+    # @return [Array<Segment>] Segments which make up this conversion
+    attr_reader :segments
+
+    # A polynomial conversion segment which applies the conversion from the
+    # lower bound (inclusive) until another segment's lower bound is
+    # encountered.
+    class Segment
+      # @return [Integer] The value at which point this polynomial conversion
+      #   should apply. All values >= to this value will be converted using the
+      #   given coefficients.
+      attr_reader :lower_bound
+
+      # @return [Array<Integer>] The polynomial coefficients
+      attr_reader :coeffs
+
+      # Creates a polynomial conversion segment. Multiple Segments are used to
+      # implemnt a {SegmentedPolynomialConversion}.
+      #
+      # @param lower_bound [Integer] The value at which point this polynomial conversion
+      #   should apply. All values >= to this value will be converted using the
+      #   given coefficients.
+      # @param coeffs [Array<Integer>] The polynomial coefficients
+      def initialize(lower_bound, coeffs)
+        @lower_bound = lower_bound
+        @coeffs = coeffs
+      end
+
+      # Implement the comparison operator to compared based on the lower_bound
+      # but sort in reverse order so the segment with the largest lower_bound
+      # comes first. This makes the calculation code in call easier.
+      #
+      # @param other_segment [Segment] The segment to compare
+      # @return [Integer] 1 if self.lower_bound > other_segment.lower_bound, 0
+      #   if they are equal, -1 if self.lower_bound < other_segment.lower_bound
+      def <=>(other_segment)
+        return other_segment.lower_bound <=> @lower_bound
+      end
+
+      # Implement equality operator primarily for ease of testing
+      #
+      # @param segment [Segment] Other segment
+      def ==(other_segment)
+        @lower_bound == other_segment.lower_bound &&
+          @coeffs == other_segment.coeffs
+      end
+
+      # Perform the polynomial conversion
+      #
+      # @param value [Numeric] The value to convert
+      # @return [Float] The converted value
+      def calculate(value)
+        converted = 0.0
+        @coeffs.length.times do |index|
+          converted += @coeffs[index].to_f * (value**index)
+        end
+        return converted
+      end
+    end
+
+    # Initialize the converted_type to :FLOAT and converted_bit_size to 64.
+    #
+    # @param segments [Array] Array of segments typically generated by as_json
+    #   Format similar to the following: [[15, [3, 2]], [10, [1, 2]]]
+    #   Where each entry is an array with the first value as the lower_bound
+    #   and the other entry is an array of the coefficients for that segment.
+    def initialize(segments = [])
+      super()
+      @segments = []
+      segments.each { |lower_bound, coeffs| add_segment(lower_bound, *coeffs) }
+      @converted_type = :FLOAT
+      @converted_bit_size = 64
+    end
+
+    # Add a segment to the segmented polynomial. The lower bound is inclusive, but
+    # is ignored for the segment with the lowest lower_bound.
+    #
+    # @param lower_bound [Integer] The value at which point this polynomial conversion
+    #   should apply. All values >= to this value will be converted using the
+    #   given coefficients.
+    # @param coeffs [Array<Integer>] The polynomial coefficients
+    def add_segment(lower_bound, *coeffs)
+      @segments << Segment.new(lower_bound, coeffs)
+      @segments.sort!
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] The value with the polynomial applied
+    def call(value, packet, buffer)
+      # Try to find correct segment
+      @segments.each do |segment|
+        return segment.calculate(value) if value >= segment.lower_bound
+      end
+
+      # Default to using segment with smallest lower_bound
+      segment = @segments[-1]
+      if segment
+        return @segments[-1].calculate(value)
+      else
+        return nil
+      end
+    end
+
+    # @return [String] The name of the class followed by a description of all
+    #   the polynomial segments.
+    def to_s
+      result = ''
+      count = 0
+      @segments.each do |segment|
+        result << "\n" if count > 0
+        result << "Lower Bound: #{segment.lower_bound} Polynomial: "
+        segment.coeffs.length.times do |index|
+          if index == 0
+            result << "#{segment.coeffs[index]}"
+          elsif index == 1
+            result << " + #{segment.coeffs[index]}x"
+          else
+            result << " + #{segment.coeffs[index]}x^#{index}"
+          end
+        end
+        count += 1
+      end
+      result
+    end
+
+    # @param (see Conversion#to_config)
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      config = ''
+      @segments.each do |segment|
+        config <<
+          "    SEG_POLY_#{read_or_write}_CONVERSION #{segment.lower_bound} #{segment.coeffs.join(' ')}\n"
+      end
+      config
+    end
+
+    def as_json(*a)
+      params = []
+      @segments.each do |segment|
+        params << [segment.lower_bound, segment.coeffs]
+      end
+      result = super(*a)
+      result['params'] = [params]
+      result
+    end
+  end
+end

data/lib/openc3/conversions/unix_time_conversion.rb

@@ -0,0 +1,68 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+require 'openc3/conversions/conversion'
+
+module OpenC3
+  # Converts a unix format time: Epoch Jan 1 1970, seconds and microseconds
+  class UnixTimeConversion < Conversion
+    # Initializes the time item to grab from the packet
+    #
+    # @param seconds_item_name [String] The telemetry item in the packet which
+    #   represents the number of seconds since the UNIX time epoch
+    # @param microseconds_item_name [String] The telemetry item in the packet
+    #   which represents microseconds
+    def initialize(seconds_item_name, microseconds_item_name = nil)
+      super()
+      @seconds_item_name = seconds_item_name
+      @microseconds_item_name = microseconds_item_name
+    end
+
+    # @param (see Conversion#call)
+    # @return [Float] Packet time in seconds since UNIX epoch
+    def call(value, packet, buffer)
+      if @microseconds_item_name
+        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), packet.read(@microseconds_item_name, :RAW, buffer)).sys
+      else
+        return Time.at(packet.read(@seconds_item_name, :RAW, buffer), 0).sys
+      end
+    end
+
+    # @return [String] The name of the class followed by the time conversion
+    def to_s
+      if @microseconds_item_name
+        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), packet.read('#{@microseconds_item_name}', :RAW, buffer)).sys"
+      else
+        return "Time.at(packet.read('#{@seconds_item_name}', :RAW, buffer), 0).sys"
+      end
+    end
+
+    # @param (see Conversion#to_config)
+    # @return [String] Config fragment for this conversion
+    def to_config(read_or_write)
+      "    #{read_or_write}_CONVERSION #{self.class.name.class_name_to_filename} #{@seconds_item_name} #{@microseconds_item_name}\n"
+    end
+
+    def as_json(*a)
+      result = super(*a)
+      result['params'] = [@seconds_item_name, @microseconds_item_name]
+      result
+    end
+  end # class UnixTimeConversion
+end