origen_testers 0.5.7 → 0.6.0

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

@@ -0,0 +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

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

@@ -0,0 +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

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

@@ -0,0 +1,109 @@
+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})/, '\1\2')
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Pinmap
+        include ::OrigenTesters::Generator
+
+        attr_accessor :pins
+        attr_accessor :pin_groups
+        attr_accessor :power_pins
+        attr_accessor :utility_pins
+
+        PIN_TYPES = ['I/O', 'I', 'O']
+        PWR_TYPES = ['Power']
+        UTL_TYPES = ['Utility', 'I/O', 'I', 'O']
+
+        def initialize # :nodoc:
+          @pins = {}
+          @pin_groups = Hash.new { |h, k| h[k] = {} }
+          @power_pins = {}
+          @utility_pins = {}
+        end
+
+        def add_pin(pin_name, attrs = {})
+          attrs = {
+            type:    'I/O',
+            comment: ''
+          }.merge(attrs)
+          pin_name = pin_name.to_sym unless pin_name.is_a? Symbol
+          if PIN_TYPES.include? attrs[:type]
+            type = attrs[:type]
+          else
+            Origen.log.error "Pinmap individual pin type '#{attrs[:type]}' must be set to one of the following: #{PIN_TYPES.join(', ')} for pin '#{pin_name}'"
+            fail
+          end
+          @pins[pin_name] = { type: type, comment: attrs[:comment] }
+        end
+
+        def add_group_pin(grp_name, pin_name, attrs = {})
+          attrs = {
+            type:    'I/O',
+            comment: ''
+          }.merge(attrs)
+          grp_name = grp_name.to_sym unless grp_name.is_a? Symbol
+          pin_name = pin_name.to_sym unless pin_name.is_a? Symbol
+          if PIN_TYPES.include? attrs[:type]
+            type = attrs[:type]
+          else
+            Origen.log.error "Pinmap group pin type '#{attrs[:type]}' must be set to one of the following: #{PIN_TYPES.join(', ')} for pin '#{pin_name}'"
+            fail
+          end
+          @pin_groups[grp_name][pin_name] = { type: attrs[:type], comment: attrs[:comment] }
+        end
+
+        def add_power_pin(pin_name, attrs = {})
+          attrs = {
+            type:    'Power',
+            comment: ''
+          }.merge(attrs)
+          pin_name = pin_name.to_sym unless pin_name.is_a? Symbol
+          if PWR_TYPES.include? attrs[:type]
+            type = attrs[:type]
+          else
+            Origen.log.error "Pinmap powerpin type '#{attrs[:type]}' must be set to one of the following: #{PWR_TYPES.join(', ')} for pin '#{pin_name}'"
+            fail
+          end
+          @power_pins[pin_name] = { type: attrs[:type], comment: attrs[:comment] }
+        end
+
+        def add_utility_pin(pin_name, attrs = {})
+          attrs = {
+            type:    'Utility',
+            comment: ''
+          }.merge(attrs)
+          pin_name = pin_name.to_sym unless pin_name.is_a? Symbol
+          if UTL_TYPES.include? attrs[:type]
+            type = attrs[:type]
+          else
+            Origen.log.error "Pinmap utility pin type '#{attrs[:type]}' must be set to one of the following: #{UTL_TYPES.join(', ')} for pin '#{pin_name}'"
+            fail
+          end
+          @utility_pins[pin_name] = { type: attrs[:type], comment: attrs[:comment] }
+        end
+
+        def finalize(options = {})
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

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

@@ -2,7 +2,7 @@ module OrigenTesters
   module IGXLBasedTester
     class Base
       class TestInstance
-        attr_accessor :type, :index, :version, :append_version, :finalize
+        attr_accessor :type, :index, :version, :append_version, :finalize, :meta
 
         def self.define
           # Generate accessors for all attributes and their aliases
@@ -46,6 +46,7 @@ module OrigenTesters
         end
 
         def initialize(name, type, attrs = {})
+          @meta = {}
           @type = type
           @append_version = true
           self.name = name
@@ -68,6 +69,35 @@ module OrigenTesters
           end
         end
 
+        # Returns a hash containing key meta data about the test instance, this is
+        # intended to be used in documentation
+        def to_meta
+          m = { 'Test' => name,
+                'Type' => type
+          }
+          if type == :functional
+            m['Pattern'] = pattern
+          elsif type == :board_pmu || type == :pin_pmu
+            m['Measure'] = fvmi? ? 'current' : 'voltage'
+            if hi_lo_limit_valid & 2 != 0
+              m['Hi'] = hi_limit
+            end
+            if hi_lo_limit_valid & 1 != 0
+              m['Lo'] = lo_limit
+            end
+            if force_cond
+              m['Force'] = force_cond
+            end
+          end
+          m['DC'] = "#{dc_category} (#{dc_selector})"
+          m['AC'] = "#{ac_category} (#{ac_selector})"
+          m.merge(@meta)
+        end
+
+        def inspect
+          "<TestInstance: #{name}, Type: #{type}>"
+        end
+
         def ==(other_instance)
           self.class == other_instance.class &&
             unversioned_name.to_s == other_instance.unversioned_name.to_s &&
@@ -167,6 +197,7 @@ module OrigenTesters
           end
           self
         end
+        alias_method :hi_limit=, :set_hi_limit
 
         # Set and enable the hi limit of a parametric test instance, passing in
         # nil or false as the lim parameter will disable the hi limit.
@@ -179,6 +210,7 @@ module OrigenTesters
           end
           self
         end
+        alias_method :lo_limit=, :set_lo_limit
 
         # Set the current range of the test instance, the following are valid:
         #

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

@@ -0,0 +1,37 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Timeset
+        attr_accessor :master_ts, :t_mode  # Timeset information
+        attr_accessor :pins
+        attr_accessor :name
+
+        # Specify timeset information by providing a pin and its associated edge timing
+        def initialize(name, pin, edge, attrs = {}) # :nodoc:
+          attrs = {
+            master_ts: '', # master timeset name
+            t_mode:    ''  # timing mode (possibly ATE-specific)
+          }.merge(attrs)
+          @master_ts = attrs[:master_ts]
+          @t_mode    = attrs[:t_mode]
+          @pins      = { pin => edge }
+          self.name = name
+        end
+
+        # Assigns a timing edge object to the given pin for this timeset
+        def add_edge(pin, edge)
+          if @pins.key?(pin)
+            Origen.log.error "Pin #{pin} already exists in timeset"
+            fail
+          else
+            @pins[pin] = edge
+          end
+        end
+
+        def platform
+          Origen.interface.platform
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Timesets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :ts
+        attr_accessor :ts_sheet_pins
+
+        OUTPUT_PREFIX = 'TS'
+        # OUTPUT_POSTFIX = 'TS'
+
+        def initialize # :nodoc:
+          @ts = {}
+        end
+
+        def add(tsname, pin, esname, options = {})
+          tsname = tsname.to_sym unless tsname.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+          esname = pin.to_sym unless esname.is_a? Symbol
+          @ts.key?(tsname) ? @ts[tsname].add_edge(pin, esname) : @ts[tsname] = platform::Timeset.new(tsname, pin, esname, options)
+          @ts_sheet_pins = options[:ts_sheet_pins] unless @ts_sheet_pins
+          @ts[tsname]
+        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
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/j750/templates/flow.txt.erb

@@ -4,6 +4,6 @@ DFF 1.1	Flow Table
 			Gate			Command				Bin Number		Sort Number			Flag			Group				Device			Debug			
 	Label	Enable	Job	Part	Env	Opcode	Parameter	TName	TNum	Pass	Fail	Pass	Fail	Result	Pass	Fail	State	Specifier	Sense	Condition	Name	Sense	Condition	Name	Assume	Sites	Comment	
 % end    
-% collection.each do |test|
-<%= test %>
+% format.each do |line|
+<%= line %>
 % end    

data/lib/origen_testers/igxl_based_tester/ultraflex/ac_specsets.rb

@@ -0,0 +1,10 @@
+module OrigenTesters
+  module IGXLBasedTester
+    class UltraFLEX
+      require 'origen_testers/igxl_based_tester/base/ac_specsets'
+      class ACSpecsets < Base::ACSpecsets
+        TEMPLATE = "#{Origen.root!}/lib/origen_testers/igxl_based_tester/ultraflex/templates/ac_specsets.txt.erb"
+      end
+    end
+  end
+end