origen_testers 0.4.0

data/lib/origen_testers/smartest_based_tester/base/test_methods/base_tml.rb

@@ -0,0 +1,38 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethods
+        # Base class of all test method libraries
+        class BaseTml
+          # Returns the test_methods object for the current flow
+          attr_reader :test_methods
+
+          def initialize(test_methods)
+            @test_methods = test_methods
+          end
+
+          def method_missing(method, *args, &block)
+            if definitions[method]
+              m = platform::TestMethod.new methods: definitions[method].dup,
+                                           attrs:   (args.first || {}),
+                                           type:    method,
+                                           library: self
+              test_methods.add(m)
+              m
+            else
+              super
+            end
+          end
+
+          def platform
+            Origen.interface.platform
+          end
+
+          def definitions
+            @definitions || self.class::TEST_METHODS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/test_methods/custom_tml.rb

@@ -0,0 +1,19 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethods
+        class CustomTml < BaseTml
+          def initialize(test_methods, definitions)
+            @definitions = definitions
+            @klass = definitions[:class_name]
+            super test_methods
+          end
+
+          def klass
+            @klass || ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/test_methods/dc_tml.rb

@@ -0,0 +1,147 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethods
+        class DcTml < BaseTml
+          TEST_METHODS = {
+            continuity:        {
+              pinlist:               [:string, '@'],
+              test_current:          [:current, 10.uA],
+              settling_time:         [:time, 1.ms],
+              measurement_mode:      [:string, 'PPMUpar', %w(PPMUpar ProgLoad)],
+              polarity:              [:string, 'SPOL', ['SPOL' 'BPOL']],
+              precharge_to_zero_vol: [:string, 'ON', %w(ON OFF)],
+              test_name:             [:string, 'passVolt_mv'],
+              output:                [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            dps_connectivity:  {
+              dps_pins:  [:string, '@'],
+              test_name: [:string, 'DPS_ForceSense'],
+              output:    [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            dps_status:        {
+              dps_pins:         [:string, '@'],
+              constant_current: [:string, 'OFF', %w(ON OFF)],
+              unregulated:      [:string, 'OFF', %w(ON OFF)],
+              over_voltage:     [:string, 'OFF', %w(ON OFF)],
+              over_power_temp:  [:string, 'OFF', %w(ON OFF)],
+              test_name:        [:string, 'DPS_Status'],
+              output:           [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            dvm:               {
+              class_name:    'DVM',
+              pinlist:       [:string, '@'],
+              settling_time: [:time, 0],
+              measure_mode:  [:string, 'PPMUpar', %w(PPMUpar ProgLoad)],
+              test_name:     [:string, 'passVoltageLimit_mV'],
+              output:        [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            general_pmu:       {
+              class_name:        'GeneralPMU',
+              pinlist:           [:string, '@'],
+              force_mode:        [:string, 'VOLT', %w(VOLT CURR)],
+              force_value:       [:force_mode, 3800.mV],
+              spmu_clamp:        [:current, 0],
+              precharge:         [:string, 'OFF', %w(ON OFF)],
+              precharge_voltage: [:voltage, 0],
+              settling_time:     [:time, 0],
+              tester_state:      [:string, 'CONNECTED', %w(CONNECTED DISCONNECTED UNCHANGED)],
+              termination:       [:string, 'OFF', %w(ON OFF)],
+              measure_mode:      [:string, 'PPMUpar', %w(PPMUpar PPMUser SPMUser)],
+              relay_switch_mode: [:string, 'DEFAULT(BBM)', ['DEFAULT(BBM)', 'BBM', 'MBB', 'PARALLEL']],
+              ppmu_clamp_low:    [:voltage, 0],
+              ppmu_clamp_high:   [:voltage, 0],
+              output:            [:string, 'None', %w(None ReportUI ShowFailOnly)],
+              test_name:         [:string, 'passLimit_uA_mV']
+            },
+            high_z:            {
+              pinlist:           [:string, '@'],
+              force_voltage:     [:voltage, 2500.mV],
+              settling_time:     [:time, 0],
+              relay_switch_mode: [:string, 'DEFAULT(BBM)', ['DEFAULT(BBM)', 'BBM', 'MBB', 'PARALLEL']],
+              test_name:         [:string, 'passCurrent_uA'],
+              output:            [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            leakage:           {
+              pinlist:                         [:string, '@'],
+              measure:                         [:string, 'BOTH', %w(BOTH LOW HIGH)],
+              force_voltage_low:               [:voltage, 400.mV],
+              force_voltage_high:              [:voltage, 3800.mV],
+              spmu_clamp_current_low:          [:current, 0],
+              spmu_clamp_current_high:         [:current, 0],
+              ppmu_pre_charge:                 [:string, 'ON', %w(ON OFF)],
+              precharge_voltage_low:           [:voltage, 0],
+              precharge_voltage_high:          [:voltage, 0],
+              settling_time_low:               [:time, 0],
+              settling_time_high:              [:time, 0],
+              pre_function:                    [:string, 'NO', %w(NO ALL ToStopVEC ToStopCYC)],
+              control_test_num_off_functional: [:string, 'NO', %w(NO ALL ToStopVEC ToStopCYC)],
+              stop_cyc_vec_low:                [:integer, 0],
+              stop_cyc_vec_high:               [:integer, 0],
+              measure_mode:                    [:string, 'PPMUpar', %w(PPMUpar PPMUser SPMUser)],
+              relay_switch_mode:               [:string, 'DEFAULT(BBM)', ['DEFAULT(BBM)', 'BBM', 'MBB', 'PARALLEL']],
+              test_name:                       [:string, '(passCurrentLow_uA,passCurrentHigh_uA)'],
+              output:                          [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            operating_current: {
+              dps_pins:    [:string, '@'],
+              samples:     [:integer, 4],
+              delay_time:  [:time, 0],
+              termination: [:string, 'OFF', %w(ON OFF)],
+              test_name:   [:string, 'passCurrLimit_uA'],
+              output:      [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            output_dc:         {
+              class_name:              'OutputDC',
+              pinlist:                 [:string, ''],
+              mode:                    [:string, 'PROGRAMLOAD', %w(PROGRAMLOAD, PPMU SPMU PPMUTERM SPMUTERM)],
+              measure_level:           [:string, 'BOTH', %(BOTH LOW HIGH)],
+              force_current_low:       [:current, 0],
+              force_current_high:      [:current, 0],
+              max_pass_low:            [:voltage, 0],
+              min_pass_low:            [:voltage, 0],
+              max_pass_high:           [:voltage, 0],
+              min_pass_high:           [:voltage, 0],
+              settling_time_low:       [:time, 0],
+              settling_time_high:      [:time, 0],
+              spmu_clamp_voltage_low:  [:voltage, 0],
+              spmu_clamp_voltage_high: [:voltage, 0],
+              vector_range:            [:string, ''],
+              test_name:               [:string, '(OutputDC_LowLevel[V],OutputDC_HighLevel[V])'],
+              output:                  [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            production_iddq:   {
+              dps_pins:                       [:string, 'Vee'],
+              disconnect_pins:                [:string, ''],
+              settling_time:                  [:time, 0],
+              stop_mode:                      [:string, 'ToStopVEC', %w(ToStopVEC ToStopCYC)],
+              str_stop_vec_cyc_num:           [:string, ''],
+              samples:                        [:integer, 16],
+              check_functional:               [:string, 'ON', %w(ON OFF)],
+              control_test_num_of_functional: [:string, 'OFF', %w(ON OFF)],
+              ganged_mode:                    [:string, 'OFF', %w(ON OFF)],
+              test_name:                      [:string, 'passCurrLimit_uA'],
+              output:                         [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            },
+            standby_current:   {
+              dps_pins:      [:string, '@'],
+              samples:       [:integer, 16],
+              termination:   [:string, 'OFF', %w(ON OFF)],
+              settling_time: [:time, 0],
+              test_name:     [:string, 'passCurrLimit_uA'],
+              output:        [:string, 'None', %w(None ReportUI ShowFailOnly)]
+            }
+          }
+
+          def dc_test
+            self
+          end
+
+          def klass
+            'dc_tml.DcTest'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/smartest_based_tester/base/test_methods/limits.rb

@@ -0,0 +1,43 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestMethods
+        class Limits
+          attr_reader :test_method
+          attr_accessor :lo_limit, :hi_limit
+
+          def initialize(test_method)
+            @test_method = test_method
+          end
+
+          def to_s
+            if !lo_limit && !hi_limit
+              "\"#{test_name}\"" + ' = "":"NA":"":"NA":"":"":""'
+            elsif !lo_limit
+              "\"#{test_name}\"" + " = \"\":\"NA\":\"#{hi_limit}\":\"LE\":\"\":\"\":\"0\""
+            elsif !hi_limit
+              "\"#{test_name}\"" + " = \"#{lo_limit}\":\"GE\":\"\":\"NA\":\"\":\"\":\"0\""
+            else
+              "\"#{test_name}\"" + " = \"#{lo_limit}\":\"GE\":\"#{hi_limit}\":\"LE\":\"\":\"\":\"0\""
+            end
+          end
+
+          def set_lo_limit(val)
+            self.lo_limit = val
+          end
+
+          def set_hi_limit(val)
+            self.hi_limit = val
+          end
+
+          private
+
+          def test_name
+            name = test_method.test_name if test_method.respond_to?(:test_name)
+            name || 'Functional'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestSuite
+        ATTRS =
+          %w(name
+             comment
+
+             timing_equation timing_spec timing_set
+             level_equation level_spec level_set
+             analog_set
+             pattern
+             context
+             test_type
+             test_method
+
+             test_number
+             test_level
+
+             bypass
+             set_pass
+             set_fail
+             hold
+             hold_on_fail
+             output_on_pass
+             output_on_fail
+             pass_value
+             fail_value
+             per_pin_on_pass
+             per_pin_on_fail
+             log_mixed_signal_waveform
+             fail_per_label
+             ffc_enable
+             log_first
+             ffv_enable
+             frg_enable
+             hardware_dsp_disable
+          )
+
+        ALIASES = {
+          tim_equ_set:     :timing_equation,
+          tim_spec_set:    :timing_spec,
+          timset:          :timing_set,
+          timeset:         :timing_set,
+          time_set:        :timing_set,
+          lev_equ_set:     :level_equation,
+          lev_spec_set:    :level_spec,
+          levset:          :level_set,
+          levels:          :level_set,
+          pin_levels:      :level_set,
+          anaset:          :analog_set,
+          test_num:        :test_number,
+          test_function:   :test_method,
+          value_on_pass:   :pass_value,
+          value_on_fail:   :fail_value,
+          seqlbl:          :pattern,
+          mx_waves_enable: :log_mixed_signal_waveform,
+          hw_dsp_disable:  :hardware_dsp_disable,
+          ffc_on_fail:     :log_first
+        }
+
+        DEFAULTS = {
+          output_on_pass:  true,
+          output_on_fail:  true,
+          pass_value:      true,
+          fail_value:      true,
+          per_pin_on_pass: true,
+          per_pin_on_fail: true
+        }
+
+        # Generate accessors for all attributes and their aliases
+        ATTRS.each do |attr|
+          attr_accessor attr.to_sym
+        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
+
+        def initialize(name, attrs = {})
+          self.name = name
+          # Set the defaults
+          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}=")
+          end
+        end
+
+        def lines
+          l = []
+          l << '  override = 1;'
+          l << " override_tim_equ_set = #{wrap_if_string(timing_equation)};" if timing_equation
+          l << " override_lev_equ_set = #{wrap_if_string(level_equation)};" if level_equation
+          l << " override_tim_spec_set = #{wrap_if_string(timing_spec)};" if timing_spec
+          l << " override_lev_spec_set = #{wrap_if_string(level_spec)};" if level_spec
+          l << " override_anaset = #{wrap_if_string(analog_set)};" if analog_set
+          l << " override_timset = #{wrap_if_string(timing_set)};" if timing_set
+          l << " override_levset = #{wrap_if_string(level_set)};" if level_set
+          l << " override_seqlbl = #{wrap_if_string(pattern)};" if pattern
+          l << " override_test_number = #{test_number};" if test_number
+          l << " override_testf = #{test_method.id};" if test_method
+          l << "  test_level = #{test_level};" if test_level
+          l << "  ffc_on_fail = #{wrap_if_string(log_first)};" if log_first
+          l << " comment = \"#{comment}\";" if comment
+          l << "local_flags  = #{flags};"
+          l << ' site_match = 2;'
+          l << ' site_control = "parallel:";'
+          l
+        end
+
+        def method_missing(method, *args, &block)
+          if test_method && test_method.respond_to?(method)
+            test_method.send(method, *args, &block)
+          else
+            super
+          end
+        end
+
+        def respond_to?(method)
+          (test_method && test_method.respond_to?(method)) || super
+        end
+
+        private
+
+        def flags
+          f = []
+          f << 'bypass' if bypass
+          f << 'set_pass' if set_pass
+          f << 'set_fail' if set_fail
+          f << 'hold' if hold
+          f << 'hold_on_fail' if hold_on_fail
+          f << 'output_on_pass' if output_on_pass
+          f << 'output_on_fail' if output_on_fail
+          f << 'value_on_pass' if pass_value
+          f << 'value_on_fail' if fail_value
+          f << 'per_pin_on_pass' if per_pin_on_pass
+          f << 'per_pin_on_fail' if per_pin_on_fail
+          f << 'mx_waves_enable' if log_mixed_signal_waveform
+          f << 'fail_per_label' if fail_per_label
+          f << 'ffc_enable' if ffc_enable
+          f << 'ffv_enable' if ffv_enable
+          f << 'frg_enable' if frg_enable
+          f << 'hw_dsp_disable' if hardware_dsp_disable
+          f.join(', ')
+        end
+
+        def wrap_if_string(value)
+          if value.is_a?(String)
+            "\"#{value}\""
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+module OrigenTesters
+  module SmartestBasedTester
+    class Base
+      class TestSuites
+        # 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 = []
+        end
+
+        def filename
+          flow.filename
+        end
+
+        def add(name, options = {})
+          name = make_unique(name)
+          suite = platform::TestSuite.new(name, options)
+          @collection << suite
+          # c = Origen.interface.consume_comments
+          # Origen.interface.descriptions.add_for_test_definition(name, c)
+          suite
+        end
+        alias_method :run, :add
+        alias_method :run_and_branch, :add
+
+        def platform
+          Origen.interface.platform
+        end
+
+        def finalize
+          collection.each do |suite|
+            if suite.pattern
+              flow.pattern_master.add suite.pattern
+              Origen.interface.pattern_master.add suite.pattern
+            end
+          end
+        end
+
+        private
+
+        def make_unique(name)
+          @existing_names ||= {}
+          if @existing_names[name]
+            @existing_names[name] += 1
+            "#{name}_#{@existing_names[name]}"
+          else
+            @existing_names[name] = 0
+            name
+          end
+        end
+      end
+    end
+  end
+end