origen_testers 0.52.5 → 0.52.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68bd4c35fef793a404ccab7d41d8212fccbdc69e2b92f7cbcbf1c711cca27b64
-  data.tar.gz: d641609bc1bccd7476dbbdce14b01745726bfdc66062709d2991f3cdf8dd6d8c
+  metadata.gz: ccd63605d6a24fffaea0ef6fa10e4f3d9078f58c36e98857bcfb7a82a7564c44
+  data.tar.gz: 9964c66bbe4042f62acf9bf56d0b579e85c8e12d6d656c79846294fb6d2289b0
 SHA512:
-  metadata.gz: df597ce4879df80783faa634975b7c5531594d60a6f230fc6495927a384ea56e2608f004d3ae5ad4ddbe9cc31609324e4c2f0b410aaf9a003e148082e50f2431
-  data.tar.gz: f3f6c2d67eabb103d31f375262729cceb99170adaba9f38d2f567fbff6ad6b6c92cdf1708aebfe77dfdb761642304a96a642f8f244cc7f0709683a0a06acf1c4
+  metadata.gz: 23694bb90289fb1381f4987b31ef47f5adf57d15551f60ad6fd0cfa335e0f12e783716c0b8d375541375082a7186e59fe4a0aaaab28189c7b668caf48aa54544
+  data.tar.gz: b32fb971c9693bd113f928e70e1d52e2c9c3052d0f44d8a8e95692752145e6946a815ec77bb11c257fd4c2a2a0080a9fc481ac525cc4cff6d5cb812df08c0722

data/config/version.rb

@@ -1,7 +1,7 @@
 module OrigenTesters
   MAJOR = 0
   MINOR = 52
-  BUGFIX = 5
+  BUGFIX = 7
   DEV = nil
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
 end

data/lib/origen_testers/decompiler/nodes.rb

@@ -103,6 +103,8 @@ module OrigenTesters
         alias_method :pinlist, :pins
 
         def initialize(pins:, context:)
+          # remove trailing formatting characters
+          pins = pins.map { |p| p.split(':').first }
           @pins = pins.map(&:strip).map(&:to_sym)
           super(context: context, type: :pinlist)
         end

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

@@ -110,6 +110,10 @@ module OrigenTesters
           new(name, :powersupply, attrs)
         end
 
+        def self.new_dcvi_powersupply(name, attrs = {})
+          new(name, :dcvi_powersupply, attrs)
+        end
+
         def self.new_mto_memory(name, attrs = {})
           new(name, :mto_memory, attrs)
         end

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

@@ -163,6 +163,10 @@ module OrigenTesters
         end
         alias_method :power_supply, :powersupply
 
+        def dcvi_powersupply(name, options = {})
+          add(name, :dcvi_powersupply, options)
+        end
+
         def ppmu(name, options = {})
           add(name, :pin_pmu, options)
         end

data/lib/origen_testers/igxl_based_tester/decompiler/atp.rb

@@ -59,6 +59,8 @@ module OrigenTesters
             nodes_namespace::CommentBlock.new(context:  self,
                                               comments: raw_vector.split("\n")
                                              )
+          elsif raw_vector.strip.size == 0
+            nodes_namespace::CommentBlock.new(context: self, comments: ['// blank line replaced with comment by origen convert'])
           elsif raw_vector =~ Regexp.new('^\s*start_label')
             nodes_namespace::StartLabel.new(context:     self,
                                             start_label: raw_vector[raw_vector.index('start_label') + 11..-1].strip[0..-2]
@@ -69,7 +71,9 @@ module OrigenTesters
                                              label_type: contents[0],
                                              label_name: contents[1]
                                             )
-          elsif raw_vector =~ Regexp.new(':(?!(.*>))')
+          # original elsif for label was updated to avoid confusing origen's eol comments for a label
+          # elsif raw_vector =~ Regexp.new(':(?!(.*>))')
+          elsif raw_vector.split(';').first =~ Regexp.new(':(?!(.*>))')
             nodes_namespace::Label.new(context:    self,
                                        # Strip any whitespace from the vector and grab contents up to
                                        # the ':' symbol.

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

@@ -18,15 +18,15 @@ module OrigenTesters
         TEST_INSTANCE_EXTRA_ARGS = 130
 
         TEST_INSTANCE_ALIASES = {
-          name:       :test_name,
-          time_set:   :time_sets,
-          timeset:    :time_sets,
-          timesets:   :time_sets,
+          name:             :test_name,
+          time_set:         :time_sets,
+          timeset:          :time_sets,
+          timesets:         :time_sets,
 
-          other:      {
+          other:            {
           },
 
-          empty:      {
+          empty:            {
             arg_list:             :arg0,
             start_func:           :arg1,
             start_of_body_f:      :arg1,
@@ -65,7 +65,7 @@ module OrigenTesters
           },
 
           # Functional test instances
-          functional: {
+          functional:       {
             arg_list:             :arg0,
             pattern:              :arg1,
             patterns:             :arg1,
@@ -125,7 +125,7 @@ module OrigenTesters
             concurrent_mode:      :arg35
           },
 
-          pin_pmu:    {
+          pin_pmu:          {
             arg_list:                :arg0,
             hsp_start:               :arg1,
             start_func:              :arg2,
@@ -206,22 +206,88 @@ module OrigenTesters
             force_cond_alt:          :arg56,
             force_irange_alt:        :arg57,
             meas_irange_alt:         :arg58
+          },
+
+          dcvi_powersupply: {
+            arg_list:             :arg0,
+            precond_pat:		        :arg1,
+            start_func:		         :arg2,
+            pre_pat_func:			      :arg3,
+            pre_test_func:			     :arg4,
+            post_test_func:		     :arg5,
+            post_pat_func:			     :arg6,
+            end_of_body_f:		      :arg7,
+            hold_state_pat:		     :arg8,
+            pattern:		            :arg8,
+            drive_lo_pins:		      :arg9,
+            drive_hi_pins:		      :arg10,
+            drive_z_pins:		       :arg11,
+            float_pins:		         :arg12,
+            sampling_time:		      :arg13,
+            sample:		             :arg14,
+            sample_size:		        :arg14,
+            settling_time:		      :arg15,
+            main_voltage:		       :arg16,
+            alt_voltage:		        :arg17,
+            power_pins:		         :arg18,
+            disable_pins:		       :arg19,
+            voltage_output:		     :arg20,
+            pcp_start_label:		    :arg21,
+            pcp_start:		          :arg21,
+            pcp_stop_label:		     :arg22,
+            pcp_stop:		           :arg22,
+            start_func_args:      :arg23,
+            start_of_body_f_args: :arg23,
+            pre_pat_func_args:    :arg24,
+            pre_pat_f_args:       :arg24,
+            pre_test_func_args:   :arg25,
+            pre_test_f_args:      :arg25,
+            post_test_func_args:  :arg26,
+            post_test_f_args:     :arg26,
+            post_pat_func_args:   :arg27,
+            post_pat_f_args:      :arg27,
+            end_func_args:        :arg28,
+            end_of_body_f_args:   :arg28,
+            hsp_start_label:		    :arg29,
+            hsp_start:		          :arg29,
+            hsp_stop_label:		     :arg30,
+            hsp_stop:		           :arg30,
+            pcp_check_patGen:		   :arg31,
+            current_clamp:		      :arg32,
+            hsp_checkpat_gen:		   :arg33,
+            hsp_resume_pat:		     :arg34,
+            relay_mode:		         :arg35,
+            utility_pins_1:       :arg36,
+            utility_pins_0:       :arg37,
+            test_control:		       :arg38,
+            serialize_meas:		     :arg39,
+            meas_f:			            :arg40,
+            meas_f_args:		        :arg41,
+            wait_flag1:           :arg42,
+            wait_flag2:           :arg43,
+            wait_flag3:           :arg44,
+            wait_flag4:           :arg45,
+            validating:           :arg46,
+            i_range:			           :arg47,
+            pattern_timeout:		    :arg48,
+            pcp_disable_alarm:		  :arg49,
+            hcp_disable_alarm:		  :arg50
           }
 
         }
 
         TEST_INSTANCE_DEFAULTS = {
-          empty:      {
+          empty:            {
             arg_list:       'StartOfBodyF,PrePatF,PreTestF,PostTestF,PostPatF,EndOfBodyF,StartOfBodyFArgs,PrePatFArgs,PreTestFArgs,PostTestFArgs,PostPatFArgs,EndOfBodyFArgs,Util1Pins,Util0Pins,DriveLoPins,DriveHiPins,DriveZPins,FloatPins,DisablePins',
             proc_type:      'VBT',
             proc_name:      'Empty_T',
             proc_called_as: 'Excel Macro'
           },
-          other:      {
+          other:            {
             proc_type:      'Other',
             proc_called_as: 'Excel Macro'
           },
-          functional: {
+          functional:       {
             arg_list:        'Patterns,StartOfBodyF,PrePatF,PreTestF,PostTestF,PostPatF,EndOfBodyF,ReportResult,ResultMode,DriveLoPins,DriveHiPins,DriveZPins,DisablePins,FloatPins,StartOfBodyFArgs,PrePatFArgs,PreTestFArgs,PostTestFArgs,PostPatFArgs,EndOfBodyFArgs,Util1Pins,Util0Pins,PatFlagF,PatFlagFArgs,RelayMode,PatThreading,MatchAllSites,WaitFlagA,WaitFlagB,WaitFlagC,WaitFlagD,Validating_,PatternTimeout,WaitTimeDomain,ConcurrentMode',
             proc_type:       'VBT',
             proc_name:       'Functional_T',
@@ -236,7 +302,7 @@ module OrigenTesters
             wait_flag4:      -2, # waitoff
             wait_time:       30
           },
-          pin_pmu:    {
+          pin_pmu:          {
             arg_list:       'HspStartLabel,StartOfBodyF,PrePatF,PreTestF,PostTestF,PostPatF,EndOfBodyF,PreconditionPat,HoldStatePat,PcpStopLabel,DriveLoPins,DriveHiPins,DriveZPins,DisablePins,FloatPins,Pins,MeasureMode,SettlingTime,ForceCond1,ForceCond2,RelayMode,StartOfBodyFArgs,PrePatFArgs,PreTestFArgs,PostTestFArgs,PostPatFArgs,EndOfBodyFArgs,PcpStartLabel,PcpCheckPatGen,HspStopLabel,HspCheckPatGen,SamplingTime,SampleCount,HspResumePat,VClampLo,VClampHi,Util1Pins,Util0Pins,WaitFlagA,WaitFlagB,WaitFlagC,WaitFlagD,Validating_,ForceIRange,MeasIRange,PatternTimeout,PcpDisableAlarmCheck,HspDisableAlarmCheck,TestingInSeries,BackgroundMeasureMode,BackgroundForceIRange,BackgroundMeasIRange,BackgroundForceCond,PinsAlt,MeasureModeAlt,ForceCondAlt,ForceIRangeAlt,MeasIRangeAlt',
             proc_type:      'VBT',
             proc_name:      'PinPmu_T',
@@ -245,7 +311,18 @@ module OrigenTesters
             wait_flag2:     -2, # waitoff
             wait_flag3:     -2, # waitoff
             wait_flag4:     -2, # waitoff
+          },
+          dcvi_powersupply: {
+            arg_list:       'PreconditionPat,StartOfBodyF,PrePatF,PreTestF,PostTestF,PostPatF,EndOfBodyF,HoldStatePat,DriveLoPins,DriveHiPins,DriveZPins,FloatPins,SamplingTime,SampleSize,SettlingTime,MainVoltage,AltVoltage,PowerPins,DisablePins,VoltageOutput,PcpStartLabel,PcpStopLabel,StartOfBodyFArgs,PrePatFArgs,PreTestFArgs,PostTestFArgs,PostPatFArgs,EndOfBodyFArgs,HspStartLabel,HspStopLabel,PcpCheckPatGen,CurrentClamp,HspCheckPatGen,HspResumePat,RelayMode,Util1Pins,Util0Pins,TestControl,SerializeMeas,MeasF,MeasFArgs,WaitFlagA,WaitFlagB,WaitFlagC,WaitFlagD,Validating_,Irange,PatternTimeout,PcpDisableAlarm,HspDisableAlarm',
+            proc_type:      'VBT',
+            proc_name:      'DCVIPowerSupply_T',
+            proc_called_as: 'Excel Macro',
+            wait_flag1:     -2, # waitoff
+            wait_flag2:     -2, # waitoff
+            wait_flag3:     -2, # waitoff
+            wait_flag4:     -2, # waitoff
           }
+
         }
 
         # Generate the instance method definitions based on the above

data/lib/origen_testers/smartest_based_tester/base/flow.rb

@@ -241,6 +241,9 @@ module OrigenTesters
           end
           test_suites.finalize
           test_methods.finalize
+          if smt8?
+            shmoo_tests.finalize
+          end
           if tester.create_limits_file && top_level?
             render_limits_file
           end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/flow.rb

@@ -10,6 +10,8 @@ module OrigenTesters
           test_suite = node.find(:object).to_a[0]
           if test_suite.is_a?(String)
             name = test_suite
+          elsif test_suite.is_a?(ShmooTest)
+            name = test_suite.name
           else
             name = test_suite.name
             test_method = test_suite.test_method
@@ -185,6 +187,10 @@ module OrigenTesters
           @sub_flows || {}
         end
 
+        def shmoo_tests
+          @shmoo_tests ||= platform::ShmooTests.new(self)
+        end
+
         def auxiliary_flows
           @auxiliary_flows || {}
         end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/generator.rb

@@ -42,6 +42,10 @@ module OrigenTesters
         def limits_workbook
           @@limits_workbook ||= LimitsWorkbook.new(manually_register: true)
         end
+
+        def shmoo_tests
+          flow.shmoo_tests
+        end
       end
     end
   end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/shmoo_test.rb

@@ -0,0 +1,426 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class V93K_SMT8
+      class ShmooTest
+        ATTRS =
+          %w(
+            name
+
+            bypass
+            target
+            result_title
+            result_type
+            result_signal
+            execution_order
+            ffc_error_count
+            axis
+          )
+
+        ALIASES = {
+          targets: :target,
+          title:   :result_title,
+          type:    :result_type,
+          signal:  :result_signal
+        }
+
+        DEFAULTS = {
+        }
+
+        NO_STRING_TYPES = [:list_strings, :list_classes, :class]
+        # Generate accessors for all attributes and their aliases
+        ATTRS.each do |attr|
+          if attr == 'name'
+            attr_reader attr.to_sym
+          else
+            attr_accessor attr.to_sym
+          end
+        end
+
+        # Define the aliases
+        ALIASES.each do |_alias, val|
+          define_method("#{_alias}=") do |v|
+            send("#{val}=", v)
+          end
+          define_method("#{_alias}") do
+            send(val)
+          end
+        end
+        attr_accessor :meta
+
+        def initialize(name, attrs = {})
+          @name = name
+          if interface.unique_test_names == :signature
+            if interface.flow.sig
+              @name = "#{name}_#{interface.flow.sig}"
+            end
+          elsif interface.unique_test_names == :flowname || interface.unique_test_names == :flow_name
+            @name = "#{name}_#{interface.flow.name.to_s.symbolize}"
+          elsif interface.unique_test_names == :preflowname || interface.unique_test_names == :pre_flow_name
+            @name = "#{interface.flow.name.to_s.symbolize}_#{name}"
+          elsif interface.unique_test_names
+            utn_string = interface.unique_test_names.to_s
+            if utn_string =~ /^prepend_/
+              utn_string = utn_string.gsub(/^prepend_/, '')
+              @name = "#{utn_string}_#{name}"
+            else
+              utn_string = utn_string.gsub(/^append_/, '')
+              @name = "#{name}_#{utn_string}"
+            end
+          end
+
+          # handle axis
+          if axis = attrs.delete(:axis)
+            axis = [axis] unless axis.is_a?(Array)
+            axis.each_with_index do |a, i|
+              aname = a.delete(:name) || "axis#{i + 1}"
+              if axes_names.include?(aname.to_sym)
+                fail "Axis name #{aname} is already used in shmoo test '#{@name}'"
+              end
+              axes << ShmooTestAxis.new(aname.to_sym, a)
+            end
+          else
+            fail 'ShmooTest must have at least one axis'
+          end
+
+          # Set the defaults
+          self.class::DEFAULTS.each do |k, v|
+            send("#{k}=", v)
+          end
+          # Then the values that have been supplied
+          attrs.each do |k, v|
+            send("#{k}=", v) if respond_to?("#{k}=") && k.to_sym != :name
+          end
+        end
+
+        def smt8?
+          tester.smt8?
+        end
+
+        def inspect
+          "<ShmooTest: #{name}>"
+        end
+
+        # The name is immutable once the shmoo test is created, this will raise an error when called
+        def name=(val, options = {})
+          fail 'Once assigned the name of a shmoo test cannot be changed!'
+        end
+
+        def interface
+          Origen.interface
+        end
+
+        def axes
+          @axes ||= []
+        end
+
+        def axes_names
+          axes.map(&:name)
+        end
+
+        def lines
+          l = []
+          l << "shmoo #{name} {"
+          if target.length > 1
+            l << "    target = \#[#{target.map(&:to_s).join(',')}];"
+          else
+            l << "    target = #{target[0]};"
+          end
+          l << "    resultTitle = \"#{result_title}\";" if result_title
+          l << "    resultType = \"#{result_type}\";" if result_type
+          l << "    resultSignal = \"#{result_signal}\";" if result_signal
+          l << "    executionOrder = #{execution_order};" if execution_order
+          l << "    bypass = \"#{bypass}\";" if bypass
+          l << "    ffcErrorCount = #{ffc_error_count};" if ffc_error_count
+          l << ''
+
+          axes.each do |a|
+            a.lines.each do |al|
+              l << al
+            end
+          end
+
+          l << '}'
+          l
+        end
+      end
+
+      class ShmooTestAxis
+        ATTRS =
+          %w(
+            name
+
+            resource_type
+            resource_name
+            setup_signal
+
+            range_resolution
+            range_steps
+            range_fast_steps
+            range_scale
+            range_list
+            range_start
+            range_stop
+            range_relative_percentage_start
+            range_relative_percentage_stop
+            range_relative_value_start
+            range_relative_value_stop
+            tracking
+          )
+
+        ALIASES = {
+          resolution: :range_resolution,
+          steps:      :range_steps,
+          fast_steps: :range_fast_steps
+        }
+
+        # Generate accessors for all attributes and their aliases
+        ATTRS.each do |attr|
+          if attr == 'name'
+            attr_reader attr.to_sym
+          else
+            attr_accessor attr.to_sym
+          end
+        end
+
+        def initialize(name, attrs = {})
+          @name = name
+
+          @resource_type = attrs.delete(:resource_type)
+          @resource_name = attrs.delete(:resource_name)
+          @setup_signal = attrs.delete(:setup_signal)
+
+          if range_list = attrs.delete(:range_list)
+            @range_list = range_list
+          elsif attrs[:range] && attrs[:range].is_a?(Array)
+            @range_list = attrs.delete(:range)
+          else
+            if range = attrs.delete(:range)
+              if range.is_a?(Range)
+                @range_start = range.begin
+                @range_stop = range.end
+                @range_steps = attrs.delete(:range_steps) || attrs.delete(:steps)
+                @range_resolution = attrs.delete(:range_resolution) || attrs.delete(:resolution)
+                @range_fast_steps = attrs.delete(:range_fast_steps) || attrs.delete(:fast_steps)
+              elsif range.is_a?(Hash)
+                @range_start = range[:start]
+                @range_stop = range[:stop]
+                @range_steps = range[:steps]
+                @range_resolution = range[:resolution]
+                @range_fast_steps = range[:fast_steps]
+              end
+            elsif range_relative_percentage = attrs.delete(:range_relative_percentage)
+              if range_relative_percentage.is_a?(Range)
+                @range_relative_percentage_start = range_relative_percentage.begin
+                @range_relative_percentage_stop = range_relative_percentage.end
+                @range_steps = attrs.delete(:range_steps) || attrs.delete(:steps)
+                @range_resolution = attrs.delete(:range_resolution) || attrs.delete(:resolution)
+                @range_fast_steps = attrs.delete(:range_fast_steps) || attrs.delete(:fast_steps)
+              elsif range_relative_percentage.is_a?(Hash)
+                @range_relative_percentage_start = range_relative_percentage[:start]
+                @range_relative_percentage_stop = range_relative_percentage[:stop]
+                @range_steps = range_relative_percentage[:steps]
+                @range_resolution = range_relative_percentage[:resolution]
+                @range_fast_steps = range_relative_percentage[:fast_steps]
+              end
+            elsif range_relative_value = attrs.delete(:range_relative_value)
+              if range_relative_value.is_a?(Range)
+                @range_relative_value_start = range_relative_value.begin
+                @range_relative_value_stop = range_relative_value.end
+                @range_steps = attrs.delete(:range_steps) || attrs.delete(:steps)
+                @range_resolution = attrs.delete(:range_resolution) || attrs.delete(:resolution)
+                @range_fast_steps = attrs.delete(:range_fast_steps) || attrs.delete(:fast_steps)
+              elsif range_relative_value.is_a?(Hash)
+                @range_relative_value_start = range_relative_value[:start]
+                @range_relative_value_stop = range_relative_value[:stop]
+                @range_steps = range_relative_value[:steps]
+                @range_resolution = range_relative_value[:resolution]
+                @range_fast_steps = range_relative_value[:fast_steps]
+              end
+            else
+              attrs.each do |k, v|
+                send("#{k}=", v) if respond_to?("#{k}=") && k.to_sym != :name
+              end
+            end
+          end
+
+          if tracking = attrs.delete(:tracking)
+            tracking = [tracking] unless tracking.is_a?(Array)
+            tracking.each_with_index do |t, i|
+              tname = t.delete(:name) || "tracking#{i + 1}"
+              if trackings_names.include?(tname.to_sym)
+                fail "Tracking name #{tname} is already used in shmoo test axis '#{@name}'"
+              end
+              trackings << ShmooTestTracking.new(tname.to_sym, t)
+            end
+          end
+
+          attrs.each do |k, v|
+            send("#{k}=", v) if respond_to?("#{k}=") && k.to_sym != :name
+          end
+        end
+
+        def lines
+          l = []
+          l << "    axis [#{name}] = {"
+          if resource_type
+            l << "        resourceType = #{resource_type};"
+          else
+            fail 'Shmoo Axis must have a resource type'
+          end
+          if resource_name
+            l << "        resourceName = \"#{resource_name}\";"
+          else
+            fail 'Shmoo Axis must have a resource name'
+          end
+          l << "        setup_signal = \"#{setup_signal}\";" if setup_signal
+          if range_list
+            l << "        range.list = \#[#{range_list.map(&:to_s).join(',')}];"
+          elsif range_start && range_stop
+            l << "        range.start = #{range_start};"
+            l << "        range.stop = #{range_stop};"
+          elsif range_relative_percentage_start && range_relative_percentage_stop
+            l << "        range.relativePercentage.start = #{range_relative_percentage_start};"
+            l << "        range.relativePercentage.stop = #{range_relative_percentage_stop};"
+          elsif range_relative_value_start && range_relative_value_stop
+            l << "        range.relativeValue.start = #{range_relative_value_start};"
+            l << "        range.relativeValue.stop = #{range_relative_value_stop};"
+          else
+            fail 'Shmoo Axis must have a range (start & stop) or range list'
+          end
+          if range_resolution && range_steps.nil?
+            l << "        range.resolution = #{range_resolution};"
+            if range_fast_steps
+              fail 'Shmoo Axis cannot have range fast steps with range resolution'
+            end
+          elsif range_steps && range_resolution.nil?
+            l << "        range.steps = #{range_steps};"
+            if range_fast_steps
+              l << "        range.fastSteps = #{range_fast_steps};"
+            end
+          elsif range_resolution.nil? && range_steps.nil?
+            fail 'Shmoo Axis must define either range resolution or range steps'
+          else
+            fail 'Shmoo Axis must define either range resolution or range steps, but not both'
+          end
+          l << '' if trackings.length > 0
+          trackings.each do |t|
+            t.lines.each do |tl|
+              l << tl
+            end
+          end
+
+          l << '    };'
+          l
+        end
+
+        def trackings
+          @trackings ||= []
+        end
+
+        def trackings_names
+          trackings.map(&:name)
+        end
+      end
+
+      class ShmooTestTracking
+        ATTRS =
+          %w(
+            name
+
+            resource_type
+            resource_name
+            setup_signal
+
+            range_list
+            range_start
+            range_stop
+            range_relative_percentage_start
+            range_relative_percentage_stop
+            range_relative_value_start
+            range_relative_value_stop
+          )
+
+        # Generate accessors for all attributes and their aliases
+        ATTRS.each do |attr|
+          if attr == 'name'
+            attr_reader attr.to_sym
+          else
+            attr_accessor attr.to_sym
+          end
+        end
+
+        def initialize(name, attrs = {})
+          @name = name
+
+          @resource_type = attrs.delete(:resource_type)
+          @resource_name = attrs.delete(:resource_name)
+          @setup_signal = attrs.delete(:setup_signal)
+
+          if range = attrs.delete(:range)
+            if range.is_a?(Range)
+              @range_start = range.begin
+              @range_stop = range.end
+            elsif range.is_a?(Hash)
+              @range_start = range[:start]
+              @range_stop = range[:stop]
+            elsif range.is_a?(Array)
+              @range_list = range
+            end
+          elsif range_relative_percentage = attrs.delete(:range_relative_percentage)
+            if range_relative_percentage.is_a?(Range)
+              @range_relative_percentage_start = range_relative_percentage.begin
+              @range_relative_percentage_stop = range_relative_percentage.end
+            elsif range_relative_percentage.is_a?(Hash)
+              @range_relative_percentage_start = range_relative_percentage[:start]
+              @range_relative_percentage_stop = range_relative_percentage[:stop]
+            end
+          elsif range_relative_value = attrs.delete(:range_relative_value)
+            if range_relative_value.is_a?(Range)
+              @range_relative_value_start = range_relative_value.begin
+              @range_relative_value_stop = range_relative_value.end
+            elsif range_relative_value.is_a?(Hash)
+              @range_relative_value_start = range_relative_value[:start]
+              @range_relative_value_stop = range_relative_value[:stop]
+            end
+          else
+            attrs.each do |k, v|
+              send("#{k}=", v) if respond_to?("#{k}=") && k.to_sym != :name
+            end
+          end
+        end
+
+        def lines
+          l = []
+          l << "        tracking [#{name}] = {"
+          if resource_type
+            l << "            resourceType = #{resource_type};"
+          else
+            fail 'Shmoo Tracking must have a resource type'
+          end
+          if resource_name
+            l << "            resourceName = \"#{resource_name}\";"
+          else
+            fail 'Shmoo Tracking must have a resource name'
+          end
+          l << "            setup_signal = \"#{setup_signal}\";" if setup_signal
+          if range_list
+            l << "            range.list = \#[#{range_list.map(&:to_s).join(',')}];"
+          elsif range_start && range_stop
+            l << "            range.start = #{range_start};"
+            l << "            range.stop = #{range_stop};"
+          elsif range_relative_percentage_start && range_relative_percentage_stop
+            l << "            range.relativePercentage.start = #{range_relative_percentage_start};"
+            l << "            range.relativePercentage.stop = #{range_relative_percentage_stop};"
+          elsif range_relative_value_start && range_relative_value_stop
+            l << "            range.relativeValue.start = #{range_relative_value_start};"
+            l << "            range.relativeValue.stop = #{range_relative_value_stop};"
+          else
+            fail 'Shmoo Tracking must have a range (start & stop) or range list'
+          end
+          l << '        };'
+          l
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/shmoo_tests.rb

@@ -0,0 +1,92 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class ShmooTests
+        # Origen::Tester::Generator not included since test suites do not have their
+        # own top-level sheet, they will be incorporated within the flow sheet
+
+        attr_accessor :flow, :collection
+
+        def initialize(flow)
+          @flow = flow
+          @collection = []
+          @existing_names = {}
+          # Test names also have to be unique vs. the current flow name
+          if tester.smt8?
+            @existing_names[flow.filename.sub('.flow', '').to_s] = true
+          end
+        end
+
+        def filename
+          flow.filename
+        end
+
+        def add(name, options = {})
+          symbol = name.is_a?(Symbol)
+          name = make_unique(name)
+          # Ensure names given as a symbol stay as a symbol, this is more for
+          # alignment to existing test cases than anything else
+          name = name.to_sym if symbol
+          shmoo = platform::ShmooTest.new(name, options)
+          @collection << shmoo
+          shmoo
+        end
+        alias_method :run, :add
+        alias_method :run_and_branch, :add
+
+        def platform
+          Origen.interface.platform
+        end
+
+        def finalize
+          # match any formatting difference between test suite shmoo and test flow shmoo
+          @collection.each do |shmoo_test|
+            shmoo_test.targets.each_with_index do |target, i|
+              target_is_a_test_suite = false
+              flow.test_suites.sorted_collection.each do |suite|
+                if suite.name.to_s == target.to_s
+                  target_is_a_test_suite = true
+                  break
+                end
+              end
+
+              unless target_is_a_test_suite
+                target_is_a_test_flow = false
+                flow.sub_flows.each do |name, path|
+                  target_name = target.to_s.gsub(' ', '_')
+                  if name.to_s.downcase == target_name.to_s.downcase
+                    target_is_a_test_flow = true
+                    shmoo_test.targets[i] = name
+                    break
+                  end
+                end
+
+                unless target_is_a_test_flow
+                  fail "Shmoo test target '#{target}' for shmoo test '#{shmoo_test.name}' not found in test suites or sub_flows"
+                end
+              end
+            end
+          end
+        end
+
+        def sorted_collection
+          @collection.sort_by { |st| st.name.to_s }
+        end
+
+        private
+
+        def make_unique(name)
+          name = name.to_s
+          tempname = name
+          i = 0
+          while @existing_names[tempname]
+            i += 1
+            tempname = "#{name}_#{i}"
+          end
+          @existing_names[tempname] = true
+          tempname
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/v93k_smt8/templates/template.flow.erb

@@ -21,6 +21,12 @@ flow <%= flow_name %> {
         <%= line %>
 %   end
 
+% end
+% shmoo_tests.sorted_collection.each do |shmoo_test|
+%   shmoo_test.lines.each do |line|
+        <%= line %>
+%   end
+
 % end
 % auxiliary_flows.each do |name, path|
         flow <%= name %> calls <%= path %> {}

data/lib/origen_testers/test/interface.rb

@@ -398,6 +398,14 @@ module OrigenTesters
         end
       end
 
+      def shmoo(name, targets, options = {})
+        if tester.v93k? && tester.smt8?
+          targets = [targets] unless targets.is_a?(Array)
+          st = shmoo_tests.run(name, { targets: targets }.merge(options))
+          flow.test st, options
+        end
+      end
+
       def por(options = {})
         options = {
           instance_not_available: true
@@ -500,13 +508,19 @@ module OrigenTesters
 
         if tester.j750? || tester.uflex?
           if tester.uflex?
-            ins = test_instances.functional(name)
-            ins.set_wait_flags(:a) if options[:duration] == :dynamic
+            if options[:pins] == :dcvi
+              ins = test_instances.dcvi_powersupply(name)
+              ins.set_wait_flags(:a) # set wait flag for tester handshake with patterns
+              ins.relay_mode = 1 # tlPowered - keep power on
+            else
+              ins = test_instances.functional(name)
+              ins.set_wait_flags(:a) if options[:duration] == :dynamic
+              ins.scale = options[:scale]
+              ins.units = options[:units]
+            end
             ins.pin_levels = options.delete(:pin_levels) if options[:pin_levels]
             ins.lo_limit = options[:lo_limit]
             ins.hi_limit = options[:hi_limit]
-            ins.scale = options[:scale]
-            ins.units = options[:units]
             ins.defer_limits = options[:defer_limits]
           else
             if options[:pins] == :hi_v

data/program/components/_prb1_main.rb

@@ -194,6 +194,7 @@ Flow.create do |options|
     
     meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45, number: 5910
     meas :bgap_voltage_meas1, number: 5920
+    meas :standby_current, pins: :dcvi, power_pins: :vdd, number: 5930
   end
 
   if tester.j750?
@@ -259,4 +260,33 @@ Flow.create do |options|
 
   double_int_type_check :type_check, number: 6035
 
+  if tester.smt8?
+    log 'shmoo test insertion works as expected, shmoo over test suite 1D'
+    range = { start: 3.0, stop: 5.0, steps: 10 }
+    axis = { name: :axis1, resource_type: 'specVariable', resource_name: 'vcc', range: range }
+    shmoo :shmoo_over_ts_1D, :cc_test_0, title: 'shmooOverTest', execution_order: :horizontal, axis: axis
+
+    log 'shmoo test insertion works as expected, shmoo over test suite 3D'
+    axis = [
+      { resource_type: :instrumentProperty, resource_name: 'vih', range_relative_percentage: -0.01..0.01, steps: 10 },
+      { resource_type: :specVariable, resource_name: 'vcc', range: 3..5, steps: 10 },
+      { resource_type: :suiteParameter, resource_name: 'forceVoltage', range: 4.8..5.2, steps: 10 }
+    ]
+    shmoo :shmoo_over_ts_3D, :erase_all, axis: axis, if_enable: 'do_erase'
+
+    log 'shmoo test insertion works as expected, shmoo over multiple test suites'
+    axis = { name: :vih, resource_type: :instrumentProperty, resource_name: 'vih', range_relative_percentage: -0.01..0.01, steps: 10 }
+    shmoo :shmoo_over_ts_multiple_ts, [:margin_read0_ckbd, :margin_read1_ckbd], title: 'shmooOverMultiTS', axis: axis 
+
+    log 'shmoo test insertion works as expected, shmoo over test flow'
+    axis = { name: :vcc, resource_type: :specVariable, resource_name: 'vcc', range: 3..5, steps: 10 }
+    shmoo :shmoo_over_tf, "200Mhz Tests", title: 'shmooOverTF', axis: axis, if_failed: :g200
+
+    log 'shmoo test insertion works as expected, shmoo with tracking parameters'
+    range = { start: 0.5, stop: 3.5, steps: 10 }
+    tracking = { name: :voh, resource_type: 'instrumentProperty', resource_name: 'voh', range_relative_value: 1..2 }
+    axis = { name: :vcc, resource_type: 'specVariable', resource_name: 'vcc', range: range, tracking: tracking }
+    shmoo :shmoo_with_tracking_para, :erase, title: 'shmooOverTF', axis: axis
+  end
+
 end

data/templates/origen_guides/program/v93ksmt8.md.erb

@@ -134,4 +134,69 @@ If you wish to have a collapse-able block for the variables, you need to set the
 flow_variable_grouping: true
 ~~~
 
+#### Built-In Shmoo Element
+
+SMT8 provides a built in shmoo element that can be used to shmoo a test suite or test flow.
+In order to add setup and execute code to the flow, create the shmoo_test object using `shmoo_tests.run(name, options)` and add it to the flow with `flow.test` method.
+
+
+Example of integrating the shmoo api in an interface:
+
+~~~ruby
+def shmoo(name, targets, options = {})
+  if tester.v93k? && tester.smt8?
+    targets = [targets] unless targets.is_a?(Array)
+    st = shmoo_tests.run(name, { targets: targets }.merge(options))
+    flow.test st, options
+  end
+end
+~~~
+
+
+Then in the flow, you can add the shmoo element to the flow with the following code:
+
+~~~ruby
+Flow.create
+  ...
+  range = { start: 3.0, stop: 5.0, steps: 10 }
+  axis = { name: :axis1, resource_type: 'specVariable', resource_name: 'vcc', range: range }
+  shmoo :shmoo_over_ts_1D, :cc_test_0, title: 'shmooOverTest', execution_order: :horizontal, axis: axis
+  ...
+end
+~~~
+
+Please see Advantest TDC Topic 253309 for details ahbout Shmoo parameters.
+
+
+The above code will generate the following flow code:
+
+~~~java
+flow <FLOW> {
+    setup {
+        ...
+        shmoo shmoo_over_ts_1D {
+            target = cc_test_0;
+            resultTitle = "shmooOverTest";
+            executionOrder = horizontal;
+		
+            axis [axis1] = {
+                resourceType = specVariable;
+                resourceName = "vcc";
+                range.start = 3.0;
+                range.stop = 5.0;
+                range.steps = 10;
+            };
+        }
+        ...
+    }
+
+    execute {
+        ...
+        shmoo_over_ts_1D.execute();
+        ...
+    }
+}
+~~~
+
+
 % end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.52.5
+  version: 0.52.7
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
+date: 2024-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -479,6 +479,8 @@ files:
 - lib/origen_testers/smartest_based_tester/v93k_smt8/generator.rb
 - lib/origen_testers/smartest_based_tester/v93k_smt8/limits_file.rb
 - lib/origen_testers/smartest_based_tester/v93k_smt8/limits_workbook.rb
+- lib/origen_testers/smartest_based_tester/v93k_smt8/shmoo_test.rb
+- lib/origen_testers/smartest_based_tester/v93k_smt8/shmoo_tests.rb
 - lib/origen_testers/smartest_based_tester/v93k_smt8/templates/limits.csv.erb
 - lib/origen_testers/smartest_based_tester/v93k_smt8/templates/template.flow.erb
 - lib/origen_testers/smartest_based_tester/v93k_smt8/test_suite.rb
@@ -615,7 +617,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: This plugin provides Origen tester models to drive ATE type testers like