automotive-ecu 0.1.0

data/lib/ecu/interfaces/dcm/gruppenkennfeld.rb

@@ -0,0 +1,9 @@
+require_relative "kennfeld"
+
+class Ecu
+  class Gruppenkennfeld < Kennfeld
+    def self.dcm_header
+      %r{^GRUPPENKENNFELD\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)\s+(?<ydim>\d+)}
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/gruppenkennlinie.rb

@@ -0,0 +1,9 @@
+require_relative "kennlinie"
+
+class Ecu
+  class Gruppenkennlinie < Kennlinie
+    def self.dcm_header
+      %r{^GRUPPENKENNLINIE\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)}
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/kennfeld.rb

@@ -0,0 +1,32 @@
+class Ecu
+  class Kennfeld < Label
+    def self.dcm_header
+      %r{^KENNFELD\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)\s+(?<ydim>\d+)}
+    end
+
+    def to_dcm
+      "#{type.upcase} #{name} #{xdim} #{ydim}\n".tap do |str|
+        str << "  LANGNAME #{description.enquote}\n" if description
+        str << "  FUNKTION #{function}\n"            if function
+        str << "  EINHEIT_X #{xunit.enquote}\n"      if xunit
+        str << "  EINHEIT_Y #{yunit.enquote}\n"      if yunit
+        str << "  EINHEIT_W #{unit.enquote}\n"       if unit
+        str << case xvalue.first
+              when Numeric then "  ST/X #{xvalue.join(" ")}\n"
+              when String  then "  ST_TX/X #{xvalue.map(&:enquote).join(" ")}\n"
+              end
+        yvalue.each_with_index do |entry, idx|
+          str << case entry
+                when Numeric then "  ST/Y #{entry}\n"
+                when String  then "  ST_TX/Y #{entry.enquote}\n"
+                end
+          str << case value[idx].first
+                when Numeric then "  WERT #{value[idx].join(" ")}\n"
+                when String  then "  TEXT #{value[idx].map(&:enquote).join(" ")}\n"
+                end
+        end
+        str << "END\n"
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/kennlinie.rb

@@ -0,0 +1,25 @@
+class Ecu
+  class Kennlinie < Label
+    def self.dcm_header
+      %r{^KENNLINIE\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)}
+    end
+
+    def to_dcm
+      "#{type.upcase} #{name} #{xdim}\n".tap do |str|
+        str << "  LANGNAME #{description.enquote}\n" if description
+        str << "  FUNKTION #{function}\n"            if function
+        str << "  EINHEIT_X #{xunit.enquote}\n"      if xunit
+        str << "  EINHEIT_W #{unit.enquote}\n"       if unit
+        str << case xvalue.first
+              when Numeric then "  ST/X #{xvalue.join(" ")}\n"
+              when String  then "  ST_TX/X #{xvalue.map(&:enquote).join(" ")}\n"
+              end
+        str << case value.first
+              when Numeric then "  WERT #{value.join(" ")}\n"
+              when String  then "  TEXT #{value.map(&:enquote).join(" ")}\n"
+              end
+        str << "END\n"
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/label.rb

@@ -0,0 +1,25 @@
+require_relative "property_parser"
+
+class Ecu
+  class Label
+    def self.from_dcm(input)
+      lines = case input
+              in Array  then input
+              in String then input.lines
+              end
+      hsh = dcm_header.extract_captures(lines.first)
+
+      hsh[:xdim] = hsh[:xdim].to_i if hsh.key?(:xdim)
+      hsh[:ydim] = hsh[:ydim].to_i if hsh.key?(:ydim)
+
+      fail "Malformed DCM" if hsh.empty?
+      fail "Malformed DCM" unless lines.last.match?(/^END$/)
+
+      lines[1..-2]
+        .map { DcmPropertyParser.call(_1) }
+        .each { hsh.merge!(_1) { |_, old, new| old + new } }
+
+      new(**hsh)
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/label_list.rb

@@ -0,0 +1,94 @@
+require_relative "functions"
+require_relative "festwert"
+require_relative "festwerteblock"
+require_relative "kennlinie"
+require_relative "gruppenkennlinie"
+require_relative "festkennlinie"
+require_relative "kennfeld"
+require_relative "gruppenkennfeld"
+require_relative "festkennfeld"
+require_relative "stuetzstellenverteilung"
+require_relative "malformed_dcm_error"
+require_relative "buffer"
+
+class Ecu
+  class LabelList
+
+    DCM_HEADER      = "KONSERVIERUNG_FORMAT 2.0"
+    BLANKLINE_REGEX = /^\s*$/
+    COMMENT_REGEX   = /^\*.*/
+
+    def self.from_dcm(str)
+      buffer     = DcmBuffer.new
+      headers    = []
+      subheaders = []
+      functions  = []
+      labels     = {}
+
+      str.each_line.lazy.with_index(1).each do |line, n|
+        line = normalize_whitespace(line)
+        case line
+        when BLANKLINE_REGEX then next
+        when COMMENT_REGEX
+          case buffer.header
+          when :pre   then headers << line[1..].strip
+          when :after then subheaders << line[1..].strip
+          when :done  then # Header time over, do nothing
+          end
+        when DCM_HEADER                         then buffer.header_seen!
+        when Functions.dcm_header               then buffer.start!(Functions, [line])
+        when Festwert.dcm_header                then buffer.start!(Festwert, [line])
+        when Festwerteblock.dcm_header          then buffer.start!(Festwerteblock, [line])
+        when Kennlinie.dcm_header               then buffer.start!(Kennlinie, [line])
+        when Gruppenkennlinie.dcm_header        then buffer.start!(Gruppenkennlinie, [line])
+        when Festkennlinie.dcm_header           then buffer.start!(Festkennlinie, [line])
+        when Kennfeld.dcm_header                then buffer.start!(Kennfeld, [line])
+        when Gruppenkennfeld.dcm_header         then buffer.start!(Gruppenkennfeld, [line])
+        when Festkennfeld.dcm_header            then buffer.start!(Festkennfeld, [line])
+        when Stuetzstellenverteilung.dcm_header then buffer.start!(Stuetzstellenverteilung, [line])
+        when "END"                              then
+          case obj = buffer.finish!(line)
+          when Label
+            fail "Duplicate label #{obj.name}" unless labels[obj.name].nil?
+
+            labels[obj.name] = obj
+          when Functions
+            fail "Duplicate functions definition" unless functions.empty?
+
+            functions = obj
+          else
+            fail "Unknown object #{obj}"
+          end
+        else
+          buffer.append!(line)
+        end
+      rescue RuntimeError => e
+        raise MalformedDcmError.new(e.message, n, str), e.message
+      end
+
+      new(labels.values, headers, subheaders, true)
+    end
+
+    def self.normalize_whitespace(line)
+      line.chomp.gsub(/[[:space:]]/, " ").rstrip
+    end
+
+    def to_dcm
+      out = []
+
+      unless headers.empty?
+        out += headers.map { "* " + _1 }.push("")
+      end
+
+      out << DCM_HEADER << ""
+
+      unless subheaders.empty?
+        out += subheaders.map { "* " + _1 }.push("")
+      end
+
+      out += map(&:to_dcm)
+
+      out.join("\n")
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/malformed_dcm_error.rb

@@ -0,0 +1,34 @@
+class Ecu
+  class MalformedDcmError < StandardError
+    attr_reader :lineno, :filecontent
+    def initialize(msg, lineno, filecontent)
+      super(msg)
+      @lineno      = lineno
+      @filecontent = filecontent
+    end
+
+    def to_s = "Malformed DCM: #{super} near line ##{lineno}"
+    def to_str = to_s
+
+    def context
+      filecontent
+        .lines
+        .each
+        .with_index(1)
+        .map { |line, n| present(line, n, n == lineno) }
+        .then { _1[ctx_startline..ctx_endline] }
+    end
+
+    def present(line, n, highlight)
+      case highlight
+        when true  then fmt(n) + " => | " + line
+        when false then fmt(n) + "    | " + line
+      end
+    end
+
+    def ctx_startline = [0, lineno - 7].max
+    def ctx_endline   = @endline ||= [filecontent.lines.count - 1, lineno + 3].min
+    def fmt_str       = "%#{(ctx_endline + 1).to_s.length}d"
+    def fmt(n)        = fmt_str % n
+  end
+end

data/lib/ecu/interfaces/dcm/property_parser.rb

@@ -0,0 +1,51 @@
+class Ecu
+  class DcmPropertyParser
+
+    def self.call(line)
+      key, _, value = line.strip.partition(/\s+/)
+      eval_property(key, value)
+    end
+
+    private
+
+    def self.eval_property(key, value)
+      case key
+      when "ST/X"        then { xvalue:      numeric_array(value) }
+      when "ST/Y"        then { yvalue:      numeric_array(value) }
+      when "WERT"        then { value:       numeric_array(value) }
+      when "ST_TX/X"     then { xvalue:      string_array(value) }
+      when "ST_TX/Y"     then { yvalue:      string_array(value) }
+      when "TEXT"        then { value:       string_array(value) }
+      when "FUNKTION"    then { function:    value }
+      when "EINHEIT_X"   then { xunit:       string_value(value) }
+      when "EINHEIT_Y"   then { yunit:       string_value(value) }
+      when "EINHEIT_W"   then { unit:        string_value(value) }
+      when "LANGNAME"    then { description: string_value(value) }
+      when "DISPLAYNAME" then { }
+      else fail ArgumentError, "Unknown key #{key}"
+      end
+    end
+
+    def self.string_value(str)
+      str.delete_surrounding('"')
+    end
+
+    def self.numeric_array(str)
+      str.split.map { Float(_1) rescue Label::InvalidValue.new(_1) }
+    end
+
+    def self.string_array(str)
+      str.scan(/"([^"]*)"/).flatten
+    end
+
+  end
+
+  class Label
+    InvalidValue = Struct.new(:value) do
+      def to_s
+        "<InvalidValue: \"#{value}\">"
+      end
+      def inspect; to_s; end
+    end
+  end
+end

data/lib/ecu/interfaces/dcm/stuetzstellenverteilung.rb

@@ -0,0 +1,20 @@
+class Ecu
+  class Stuetzstellenverteilung < Label
+    def self.dcm_header
+      %r{STUETZSTELLENVERTEILUNG\s+(?<name>[A-Za-z0-9\._]+)\s+(?<xdim>\d+)}
+    end
+
+    def to_dcm
+      "#{type.upcase} #{name} #{xdim}\n".tap do |str|
+        str << "  LANGNAME #{description.enquote}\n" if description
+        str << "  FUNKTION #{function}\n"            if function
+        str << "  EINHEIT_X #{xunit.enquote}\n"      if xunit
+        str << case xvalue.first
+        when Numeric then "  ST/X #{xvalue.join(" ")}\n"
+        when String then  "  ST_TX/X #{xvalue.map(&:enquote).join(" ")}\n"
+        end
+        str << "END\n"
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/lab/combined_list.rb

@@ -0,0 +1,32 @@
+require_relative "signal_list"
+require_relative "label_list"
+
+class Ecu
+  class CombinedList
+    def self.from_lab(str)
+      signals, labels, headers, subheaders = LabParser.call(str)
+      new(signals, labels, headers, subheaders)
+    end
+
+    def to_lab
+      out = []
+
+      out.append(*headers.map { |l| "; #{l}" }, "") unless headers.empty?
+
+      out.append("[SETTINGS]")
+      out.append("Version;V1.1")
+      out.append("MultiRasterSeparator;&")
+      out.append("")
+
+      out.append(*subheaders.map { |l| "; #{l}" }, "") unless subheaders.empty?
+
+      out.append("[RAMCELL]")
+      out.append(*signals.map(&:to_lab))
+
+      out.append("[Label]")
+      out.append(*labels.map(&:to_lab))
+
+      out.join("\n")
+    end
+  end
+end

data/lib/ecu/interfaces/lab/lab_parser.rb

@@ -0,0 +1,61 @@
+require_relative "../../labels"
+require_relative "../../signals"
+
+class LabParser
+  def self.call(str)
+    lines = str.lines
+
+    [
+      extract_signals(block_bounded_by(lines, "[RAMCELL]", /\A\[/)),
+      extract_labels(block_bounded_by(lines, "[Label]", /\A\[/)),
+      extract_headers(block_bounded_by(lines, 0, "[SETTINGS]")),
+      extract_headers(block_bounded_by(lines, "[SETTINGS]", /\A\[/)),
+    ]
+  end
+
+  def self.extract_labels(lines)
+    Ecu::LabelList.new lines.
+      reject { |l| l.blank? }.
+      reject { |l| l.start_with?(";") }.
+      map { |l| Ecu::Label.from_lab(l) }
+  end
+
+  def self.extract_signals(lines)
+    Ecu::SignalList.new lines.
+      reject { |l| l.blank? }.
+      reject { |l| l.start_with?(";") }.
+      map { |l| Ecu::Signal.from_lab(l) }
+  end
+
+  def self.extract_headers(lines)
+    lines.
+      select { |l| l.match(/\A; /) }.
+      map { |l| l[2..-1].chomp }
+  end
+
+  def self.block_bounded_by(lines, upper, lower)
+    upper = case upper
+            when Integer then upper
+            when String
+              return [] unless lines.any? { |l| l.strip.downcase == upper.downcase }
+              lines.index { |l| l.strip.downcase == upper.downcase } + 1
+            when Regexp
+              return [] unless lines.any? { |l| l.match?(upper) }
+              lines.index { |l| l.match?(upper) } + 1
+            end
+
+    segment = lines[upper..-1]
+
+    lower = case lower
+            when Integer then lower
+            when String
+              return lines[upper..-1] unless segment.any? { |l| l.strip.downcase == lower.downcase }
+              upper + segment.index { |l| l.strip.downcase == lower.downcase }
+            when Regexp
+              return lines[upper..-1] unless segment.any? { |l| l.match?(lower) }
+              upper + segment.index { |l| l.match?(lower) }
+            end
+
+    lines[upper...lower]
+  end
+end

data/lib/ecu/interfaces/lab/label.rb

@@ -0,0 +1,21 @@
+class Ecu
+  class Label
+
+    # This is a silly hack, since the *.lab file doesn't contain any information
+    # about the label in question (just the name). Subsequently, just initialize
+    # a Festwert with no value and hope if does the job correctly
+
+    def self.from_lab(line)
+      name, description = line.strip.split(";")
+      if description.nil?
+        Festwert.new(name: name, value: nil)
+      else
+        Festwert.new(name: name, value: nil, description: description)
+      end
+    end
+
+    def to_lab
+      "#{name};#{description}"
+    end
+  end
+end

data/lib/ecu/interfaces/lab/label_list.rb

@@ -0,0 +1,29 @@
+require_relative "../../../core_ext"
+require_relative "lab_parser"
+
+class Ecu
+  class LabelList
+    def self.from_lab(str)
+      _, labels, headers, subheaders = LabParser.call(str)
+      new(labels, headers, subheaders)
+    end
+
+    def to_lab
+      out = []
+
+      out.append(*headers.map { |l| "; #{l}" }, "") unless headers.empty?
+
+      out.append("[SETTINGS]")
+      out.append("Version;V1.1")
+      out.append("MultiRasterSeparator;&")
+      out.append("")
+
+      out.append(*subheaders.map { |l| "; #{l}" }, "") unless subheaders.empty?
+
+      out.append("[Label]")
+      out.append(*map(&:to_lab))
+
+      out.join("\n")
+    end
+  end
+end

data/lib/ecu/interfaces/lab/signal.rb

@@ -0,0 +1,15 @@
+class Ecu
+  class Signal
+    def self.from_lab(line)
+      name, tasks, comment = line.strip.split(";")
+      maintask             = tasks.split("&").first rescue nil
+      new(name: name,
+          task: maintask,
+          description: comment&.strip)
+    end
+
+    def to_lab
+      "#{name};#{task};#{description}"
+    end
+  end
+end

data/lib/ecu/interfaces/lab/signal_list.rb

@@ -0,0 +1,29 @@
+require_relative "../../../core_ext"
+require_relative "lab_parser"
+
+class Ecu
+  class SignalList
+    def self.from_lab(str)
+      signals, _, headers, subheaders = LabParser.call(str)
+      new(signals, headers, subheaders)
+    end
+
+    def to_lab
+      out = []
+
+      out.append(*headers.map { |l| "; #{l}" }, "") unless headers.empty?
+
+      out.append("[SETTINGS]")
+      out.append("Version;V1.1")
+      out.append("MultiRasterSeparator;&")
+      out.append("")
+
+      out.append(*subheaders.map { |l| "; #{l}" }, "") unless subheaders.empty?
+
+      out.append("[RAMCELL]")
+      out.append(*map(&:to_lab))
+
+      out.join("\n")
+    end
+  end
+end

data/lib/ecu/interfaces/mfile/festwert.rb

@@ -0,0 +1,10 @@
+class Ecu
+  class Festwert < Label
+    def to_mfile
+      case value
+      when Numeric then "#{name} = #{value};\n"
+      when String  then "#{name} = '#{value}';\n"
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/mfile/festwerteblock.rb

@@ -0,0 +1,12 @@
+class Ecu
+  class Festwerteblock < Label
+    def to_mfile
+      "#{name} = [\n".tap do |str|
+        value.each do |row|
+          str << row.join("  ").indent << "\n"
+        end
+        str << "];\n"
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/mfile/kennfeld.rb

@@ -0,0 +1,12 @@
+class Ecu
+  class Kennfeld < Label
+    def to_mfile
+      "#{name} = [\n".tap do |str|
+        value.each do |row|
+          str << row.join("  ").indent << "\n"
+        end
+        str << "];\n"
+      end
+    end
+  end
+end

data/lib/ecu/interfaces/mfile/kennlinie.rb

@@ -0,0 +1,7 @@
+class Ecu
+  class Kennlinie < Label
+    def to_mfile
+      "#{name} = [#{value.join("  ")}];\n"
+    end
+  end
+end

data/lib/ecu/interfaces/mfile/label_list.rb

@@ -0,0 +1,13 @@
+require_relative "festwert"
+require_relative "festwerteblock"
+require_relative "kennlinie"
+require_relative "kennfeld"
+require_relative "stuetzstellenverteilung"
+
+class Ecu
+  class LabelList
+    def to_mfile
+      self.map(&:to_mfile).join("\n")
+    end
+  end
+end

data/lib/ecu/interfaces/mfile/stuetzstellenverteilung.rb

@@ -0,0 +1,7 @@
+class Ecu
+  class Stuetzstellenverteilung < Label
+    def to_mfile
+      "#{name} = [#{xvalue.join("  ")}];\n"
+    end
+  end
+end

data/lib/ecu/labels/festwert.rb

@@ -0,0 +1,58 @@
+require_relative "label"
+
+class Ecu
+  class Festwert < Label
+
+    attr_reader :value, :unit
+
+    def initialize(name:,
+                   value:,
+                   unit: nil,
+                   function: nil,
+                   description: nil)
+      @name        = name
+      @value       = value.is_a?(Array) ? value.first : value
+      @unit        = unit
+      @function    = function
+      @description = description
+    end
+
+    def round_to(n)
+      return self unless value.is_a?(Numeric)
+      self.with \
+        value: value.round(n)
+    end
+
+    def bytesize
+      BYTESIZE[:number]
+    end
+
+    def to_s(detail: false)
+      if detail == :justvalue
+        value.to_s
+      elsif detail == :value
+        "#{name}: #{value}"
+      elsif detail == :onelinefull
+        "#{name}: #{to_s(detail: :oneline)}"
+      elsif detail == :oneline
+        "#{value}"
+      elsif detail
+        <<~EOS
+        #{name}: #{type}
+          Value: #{value}
+          Unit: "#{unit}"
+        EOS
+      else
+        "#{name}: #{type}"
+      end
+    end
+
+    def properties
+      [:name, :value, :unit, :function, :description]
+    end
+
+    def equality_properties
+      [:name, :value]
+    end
+  end
+end