origen_testers 0.13.1 → 0.13.2

data/lib/origen_testers/igxl_based_tester/base/level_supply.rb

@@ -1,39 +1,39 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class SupplyLevel
-        attr_accessor :vmain, :valt     # Supply level information
-        attr_accessor :ifold            # Clamp current information
-        attr_accessor :delay            # Supply power-up delay
-
-        def initialize(options = {}) # :nodoc:
-          options = {
-            vmain: 1.8,                # Main supply voltage
-            valt:  1.8,                # Alternate supply voltage
-            ifold: 1,                # Supply clamp current
-            delay: 0                 # Supply power-up delay
-          }.merge(options)
-          @vmain = options[:vmain]
-          @valt  = options[:valt]
-          @ifold = options[:ifold]
-          @delay = options[:delay]
-        end
-
-        def ==(level)
-          if level.is_a? PinLevelSingle
-            vmain == level.vmain &&
-              valt == level.valt &&
-              ifold == level.ifold &&
-              delay == level.delay
-          else
-            super
-          end
-        end
-
-        def platform
-          Origen.interface.platform
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class SupplyLevel
+        attr_accessor :vmain, :valt     # Supply level information
+        attr_accessor :ifold            # Clamp current information
+        attr_accessor :delay            # Supply power-up delay
+
+        def initialize(options = {}) # :nodoc:
+          options = {
+            vmain: 1.8,                # Main supply voltage
+            valt:  1.8,                # Alternate supply voltage
+            ifold: 1,                # Supply clamp current
+            delay: 0                 # Supply power-up delay
+          }.merge(options)
+          @vmain = options[:vmain]
+          @valt  = options[:valt]
+          @ifold = options[:ifold]
+          @delay = options[:delay]
+        end
+
+        def ==(level)
+          if level.is_a? PinLevelSingle
+            vmain == level.vmain &&
+              valt == level.valt &&
+              ifold == level.ifold &&
+              delay == level.delay
+          else
+            super
+          end
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/levels.rb

@@ -1,31 +1,31 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Levels
-        include ::OrigenTesters::Generator
-
-        # If levels are defined for a power group then this will return the level object
-        attr_accessor :pwr_group
-        # If levels are defined for a pin group then this will return the level object
-        attr_accessor :pin_group
-
-        def initialize(options = {}) # :nodoc:
-          @pwr_group = Hash.new { |h, k| h[k] = {} }
-          @pin_group = Hash.new { |h, k| h[k] = {} }
-        end
-
-        # Defines a new Power Level category for the given pin/group
-        def add_power_level(cat, options = {})
-          cat = cat.to_sym unless cat.is_a? Symbol
-          pwr_group[cat] = platform::SupplyLevel.new(options)
-        end
-
-        # Defines a new Single-Ended Pin Level category for the given pin/group
-        def add_se_pin_level(cat, options = {})
-          cat = cat.to_sym unless cat.is_a? Symbol
-          pin_group[cat] = platform::PinLevelSingle.new(options)
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Levels
+        include ::OrigenTesters::Generator
+
+        # If levels are defined for a power group then this will return the level object
+        attr_accessor :pwr_group
+        # If levels are defined for a pin group then this will return the level object
+        attr_accessor :pin_group
+
+        def initialize(options = {}) # :nodoc:
+          @pwr_group = Hash.new { |h, k| h[k] = {} }
+          @pin_group = Hash.new { |h, k| h[k] = {} }
+        end
+
+        # Defines a new Power Level category for the given pin/group
+        def add_power_level(cat, options = {})
+          cat = cat.to_sym unless cat.is_a? Symbol
+          pwr_group[cat] = platform::SupplyLevel.new(options)
+        end
+
+        # Defines a new Single-Ended Pin Level category for the given pin/group
+        def add_se_pin_level(cat, options = {})
+          cat = cat.to_sym unless cat.is_a? Symbol
+          pin_group[cat] = platform::PinLevelSingle.new(options)
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/levelset.rb

@@ -1,110 +1,110 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Levelset
-        include ::OrigenTesters::Generator
-
-        attr_accessor :pins
-        attr_accessor :spec_sheet
-        attr_accessor :ls_sheet_pins
-
-        # Levelset name
-        attr_accessor :name
-
-        OUTPUT_PREFIX = 'LV'
-        # OUTPUT_POSTFIX = 'LV'
-
-        def initialize(options = {}) # :nodoc:
-          @pins = {}
-        end
-
-        # rubocop:disable Metrics/ParameterLists
-
-        # Adds a pin level to the given levelset
-        def add(lsname, pin, level, options = {})
-          options = {
-            spec_sheet: 'default'  # defines which specset sheet to put variables in (e.g. func, scan) when generating specset files
-          }.merge(options)
-          lsname = lsname.to_sym unless lsname.is_a? Symbol
-          pin = pin.to_sym unless pin.is_a? Symbol
-
-          add_level(pin, level)
-          @name = lsname
-          @spec_sheet = options[:spec_sheet]
-          @ls_sheet_pins = options[:ls_sheet_pins] unless @ls_sheet_pins
-        end
-
-        # Assigns a level object to the given pin for this levelset
-        def add_level(pin, level)
-          if @pins.key?(pin)
-            Origen.log.error "Pin #{pin} already exists in levelset"
-          else
-            @pins[pin] = level
-          end
-        end
-
-        def finalize(options = {})
-        end
-
-        # Populate an array of pins based on the pin or pingroup
-        def get_pin_objects(grp)
-          pins = []
-          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
-             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
-            pins << Origen.top_level.pin(grp)
-          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
-            Origen.top_level.pin(grp).each do |pin|
-              pins << pin
-            end
-          else
-            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
-          end
-          pins
-        end
-
-        # Equality check to compare full contents of 2 level objects
-        def levels_eql?(level1, level2)
-          level1 == level2
-        end
-
-        # Globally modify text within the level object
-        def gsub_levels!(level, old_val, new_val)
-          # determine if object is a power level (conatins :vmain) or a SE pin level (:vil)
-          if level.respond_to?(:vmain)
-            level.vmain     = level.vmain.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.valt      = level.valt.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.ifold     = level.ifold.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            # level.delay     = level.delay.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          elsif level.respond_to?(:vil)
-            level.vil       = level.vil.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.vih       = level.vih.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.vol       = level.vol.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.voh       = level.voh.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.vcl       = level.vcl.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.vch       = level.vch.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.vt        = level.vt.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.voutlotyp = level.voutlotyp.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.vouthityp = level.vouthityp.gsub(/#{Regexp.escape(old_val)}/, new_val)
-            level.dmode     = level.dmode.gsub(/#{Regexp.escape(old_val)}/, new_val)
-          end
-        end
-
-        def format_uflex_level(data, options = {})
-          options = {
-          }.merge(options)
-
-          if data !~ /^\s*$/
-            data = data.gsub(/^/, '=')
-          end
-          data = data.gsub(/(\W)([a-zA-Z])/, '\1_\2')
-          data = data.gsub(/(\*\s*)_([kmun]{0,1}[AVs]{1}\W)/, '\1\2')
-          data = data.gsub(/(\*\s*)_([kmun]{0,1}[AVs]{1})$/, '\1\2')
-        end
-
-        def platform
-          Origen.interface.platform
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Levelset
+        include ::OrigenTesters::Generator
+
+        attr_accessor :pins
+        attr_accessor :spec_sheet
+        attr_accessor :ls_sheet_pins
+
+        # Levelset name
+        attr_accessor :name
+
+        OUTPUT_PREFIX = 'LV'
+        # OUTPUT_POSTFIX = 'LV'
+
+        def initialize(options = {}) # :nodoc:
+          @pins = {}
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+
+        # Adds a pin level to the given levelset
+        def add(lsname, pin, level, options = {})
+          options = {
+            spec_sheet: 'default'  # defines which specset sheet to put variables in (e.g. func, scan) when generating specset files
+          }.merge(options)
+          lsname = lsname.to_sym unless lsname.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+
+          add_level(pin, level)
+          @name = lsname
+          @spec_sheet = options[:spec_sheet]
+          @ls_sheet_pins = options[:ls_sheet_pins] unless @ls_sheet_pins
+        end
+
+        # Assigns a level object to the given pin for this levelset
+        def add_level(pin, level)
+          if @pins.key?(pin)
+            Origen.log.error "Pin #{pin} already exists in levelset"
+          else
+            @pins[pin] = level
+          end
+        end
+
+        def finalize(options = {})
+        end
+
+        # Populate an array of pins based on the pin or pingroup
+        def get_pin_objects(grp)
+          pins = []
+          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
+             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
+            pins << Origen.top_level.pin(grp)
+          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
+            Origen.top_level.pin(grp).each do |pin|
+              pins << pin
+            end
+          else
+            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
+          end
+          pins
+        end
+
+        # Equality check to compare full contents of 2 level objects
+        def levels_eql?(level1, level2)
+          level1 == level2
+        end
+
+        # Globally modify text within the level object
+        def gsub_levels!(level, old_val, new_val)
+          # determine if object is a power level (conatins :vmain) or a SE pin level (:vil)
+          if level.respond_to?(:vmain)
+            level.vmain     = level.vmain.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.valt      = level.valt.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.ifold     = level.ifold.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            # level.delay     = level.delay.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          elsif level.respond_to?(:vil)
+            level.vil       = level.vil.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.vih       = level.vih.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.vol       = level.vol.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.voh       = level.voh.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.vcl       = level.vcl.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.vch       = level.vch.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.vt        = level.vt.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.voutlotyp = level.voutlotyp.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.vouthityp = level.vouthityp.gsub(/#{Regexp.escape(old_val)}/, new_val)
+            level.dmode     = level.dmode.gsub(/#{Regexp.escape(old_val)}/, new_val)
+          end
+        end
+
+        def format_uflex_level(data, options = {})
+          options = {
+          }.merge(options)
+
+          if data !~ /^\s*$/
+            data = data.gsub(/^/, '=')
+          end
+          data = data.gsub(/(\W)([a-zA-Z])/, '\1_\2')
+          data = data.gsub(/(\*\s*)_([kmun]{0,1}[AVs]{1}\W)/, '\1\2')
+          data = data.gsub(/(\*\s*)_([kmun]{0,1}[AVs]{1})$/, '\1\2')
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/base/patgroup.rb

@@ -1,109 +1,109 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Patgroup
-        attr_accessor :index
-
-        class Pattern
-          ATTRS = %w(group_name pattern_file comment)
-
-          ALIASES = {
-            pattern: :pattern_file
-          }
-
-          DEFAULTS = {
-          }
-
-          # Generate accessors for all attributes and their aliases
-          ATTRS.each do |attr|
-            attr_accessor attr.to_sym
-          end
-
-          ALIASES.each do |_alias, val|
-            define_method("#{_alias}=") do |v|
-              send("#{val}=", v)
-            end
-            define_method("#{_alias}") do
-              send(val)
-            end
-          end
-
-          def initialize(patgroup, attrs = {})
-            # Set the defaults
-            DEFAULTS.each do |k, v|
-              send("#{k}=", v)
-            end
-            # Then the values that have been supplied
-            self.group_name = patgroup
-            attrs.each do |k, v|
-              send("#{k}=", v)
-            end
-          end
-
-          def to_s
-            l = "\t"
-            ATTRS.each do |attr|
-              l += "#{send(attr)}\t"
-            end
-            "#{l}"
-          end
-        end
-
-        # Specify multiple patterns by passing an array of attributes
-        # as the 2nd argument:
-        #
-        #   Patset.new("mrd1_pgrp", :pattern => "nvm_mrd1.PAT")
-        #
-        #   Patset.new("mrd1_pgrp", [{:pattern => "nvm_mrd1.PAT"},
-        #                            {:pattern => "nvm_global_subs.PAT},
-        #                           ])
-        def initialize(name, attrs = {})
-          attrs = [attrs] unless attrs.is_a? Array
-          attrs.each do |pattrs|
-            if pattrs[:pattern]
-              pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
-              Origen.interface.referenced_patterns << pat
-            end
-            lines << Pattern.new(name, pattrs)
-          end
-          self.name = name
-        end
-
-        def ==(other_patgroup)
-          self.class == other_patgroup.class &&
-            name.to_s == other_patgroup.name.to_s &&
-            sorted_pattern_files == other_patgroup.sorted_pattern_files
-        end
-
-        def name
-          @name
-        end
-
-        def name=(n)
-          @name = n
-          lines.each { |l| l.group_name = n }
-          n
-        end
-
-        # Returns all lines in the pattern set
-        def lines
-          @lines ||= []
-        end
-
-        # Returns all pattern files in the pattern set in alphabetical order
-        def sorted_pattern_files
-          @lines.map(&:file_name).sort
-        end
-
-        # Returns the fully formatted pattern group for insertion into a patgroups sheet
-        def to_s
-          l = ''
-          lines.each do |line|
-            l += "#{line}\r\n"
-          end
-          l.chomp
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Patgroup
+        attr_accessor :index
+
+        class Pattern
+          ATTRS = %w(group_name pattern_file comment)
+
+          ALIASES = {
+            pattern: :pattern_file
+          }
+
+          DEFAULTS = {
+          }
+
+          # Generate accessors for all attributes and their aliases
+          ATTRS.each do |attr|
+            attr_accessor attr.to_sym
+          end
+
+          ALIASES.each do |_alias, val|
+            define_method("#{_alias}=") do |v|
+              send("#{val}=", v)
+            end
+            define_method("#{_alias}") do
+              send(val)
+            end
+          end
+
+          def initialize(patgroup, attrs = {})
+            # Set the defaults
+            DEFAULTS.each do |k, v|
+              send("#{k}=", v)
+            end
+            # Then the values that have been supplied
+            self.group_name = patgroup
+            attrs.each do |k, v|
+              send("#{k}=", v)
+            end
+          end
+
+          def to_s
+            l = "\t"
+            ATTRS.each do |attr|
+              l += "#{send(attr)}\t"
+            end
+            "#{l}"
+          end
+        end
+
+        # Specify multiple patterns by passing an array of attributes
+        # as the 2nd argument:
+        #
+        #   Patset.new("mrd1_pgrp", :pattern => "nvm_mrd1.PAT")
+        #
+        #   Patset.new("mrd1_pgrp", [{:pattern => "nvm_mrd1.PAT"},
+        #                            {:pattern => "nvm_global_subs.PAT},
+        #                           ])
+        def initialize(name, attrs = {})
+          attrs = [attrs] unless attrs.is_a? Array
+          attrs.each do |pattrs|
+            if pattrs[:pattern]
+              pat = Pathname.new(pattrs[:pattern].gsub('\\', '/')).basename('.*').to_s
+              Origen.interface.referenced_patterns << pat
+            end
+            lines << Pattern.new(name, pattrs)
+          end
+          self.name = name
+        end
+
+        def ==(other_patgroup)
+          self.class == other_patgroup.class &&
+            name.to_s == other_patgroup.name.to_s &&
+            sorted_pattern_files == other_patgroup.sorted_pattern_files
+        end
+
+        def name
+          @name
+        end
+
+        def name=(n)
+          @name = n
+          lines.each { |l| l.group_name = n }
+          n
+        end
+
+        # Returns all lines in the pattern set
+        def lines
+          @lines ||= []
+        end
+
+        # Returns all pattern files in the pattern set in alphabetical order
+        def sorted_pattern_files
+          @lines.map(&:file_name).sort
+        end
+
+        # Returns the fully formatted pattern group for insertion into a patgroups sheet
+        def to_s
+          l = ''
+          lines.each do |line|
+            l += "#{line}\r\n"
+          end
+          l.chomp
+        end
+      end
+    end
+  end
+end