origen_testers 0.52.5 → 0.52.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68bd4c35fef793a404ccab7d41d8212fccbdc69e2b92f7cbcbf1c711cca27b64
-  data.tar.gz: d641609bc1bccd7476dbbdce14b01745726bfdc66062709d2991f3cdf8dd6d8c
+  metadata.gz: ea6ace3a51f5db9a3b42ab1adef04fa976ad674c9c8e1db5e6a0562a78bf0941
+  data.tar.gz: 4fabf65687d335e073f331876217810edd38a7b91e6afb14184fb1a6f0e186c2
 SHA512:
-  metadata.gz: df597ce4879df80783faa634975b7c5531594d60a6f230fc6495927a384ea56e2608f004d3ae5ad4ddbe9cc31609324e4c2f0b410aaf9a003e148082e50f2431
-  data.tar.gz: f3f6c2d67eabb103d31f375262729cceb99170adaba9f38d2f567fbff6ad6b6c92cdf1708aebfe77dfdb761642304a96a642f8f244cc7f0709683a0a06acf1c4
+  metadata.gz: 62c5e05ff8b61b625dbe5f394217447f8b3fbe47c3354c074403f4234555f7ae10f38a64b8a01c27c0b9ba00c8d54a87c335ad4e3554b50c801a75d4e73d8621
+  data.tar.gz: 37e24209edf371cbb9e723161c0316158d06d915d34f1ee26297f45522397444e7369e8255e132036327f2ea0ad657c66c7095df9a10cbff7f1638e1c8a92f39

data/config/version.rb

@@ -1,7 +1,7 @@
 module OrigenTesters
   MAJOR = 0
   MINOR = 52
-  BUGFIX = 5
+  BUGFIX = 6
   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/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/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

data/program/components/_prb1_main.rb

@@ -259,4 +259,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.6
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-07-18 00:00:00.000000000 Z
+date: 2024-08-28 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.2.3
 signing_key: 
 specification_version: 4
 summary: This plugin provides Origen tester models to drive ATE type testers like