origen_testers 0.5.7 → 0.6.0

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

@@ -95,6 +95,10 @@ module OrigenTesters
           end
         end
 
+        def inspect
+          "<TestSuite: #{name}>"
+        end
+
         # The name is immutable once the test_suite is created, this will raise an error when called
         def name=(val, options = {})
           fail 'Once assigned the name of a test suite cannot be changed!'

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

@@ -28,6 +28,9 @@ declarations
 %   flow_control_variables.each do |var|
 @<%= var.to_s.upcase %> = -1;
 %   end
+%   runtime_control_variables.each do |var|
+@<%= var.to_s.upcase %> = -1;
+%   end
 % end
 end
 --------------------------------------------------
@@ -160,16 +163,12 @@ test_flow
 %   end
 % else
 {
-%   flow_control_variables.each do |var|
+%   runtime_control_variables.each do |var|
     @<%= var.to_s.upcase %> = -1;
 %   end
 }, open,"Init Flow Control Vars", ""
-%   collection.each do |node|
-%     unless node.rendered? || node.deleted? || node.empty?
-%       node.lines.each do |line|
+%   lines.each do |line|
 <%= line %>
-%       end
-%     end
 %   end
 % end
 end

data/lib/origen_testers/test/dut.rb

@@ -20,6 +20,11 @@ module OrigenTesters
         add_pin :tdi
         add_pin :tdo
         add_pin :tms
+        # add_pin_group :jtag, :tdi, :tdo, :tms
+        add_power_pin_group :vdd1
+        add_power_pin_group :vdd2
+        add_virtual_pin :virtual1, type: :virtual_pin
+        add_virtual_pin :virtual2, type: :ate_ch
 
         reg :testme32, 0x007a do |reg|
           reg.bits 31..16, :portB

data/lib/origen_testers/test/j750_base_interface.rb

@@ -111,9 +111,6 @@ module OrigenTesters
           end
         end
       end
-
-      def bin(number, options = {})
-      end
     end
   end
 end

data/lib/origen_testers/test/ultraflex_interface.rb

@@ -51,6 +51,11 @@ module OrigenTesters
         ins = test_instances.functional(name)
         ins.set_wait_flags(:a) if options[:duration] == :dynamic
         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]
 
         pname = "#{name}_pset"
         patsets.add(pname, [{ pattern: "#{name}.PAT" },
@@ -59,10 +64,7 @@ module OrigenTesters
         if options[:cz_setup]
           flow.cz(ins, options[:cz_setup], options)
         else
-          use_limit_params = [:lo_limit, :hi_limit, :scale, :units] # define options to strip for flow.test
-          options_use_limit = options.dup                           # duplicate, as modifying options directly, even an assigned copy modifies original
-          flow.test(ins, options.reject! { |k, _| use_limit_params.include? k })    # set up test skipping use-limit options
-          flow.use_limit(name, options_use_limit) if options_use_limit[:hi_limit] || options_use_limit[:lo_limit]  # Only use use-limit if limits present in flow
+          flow.test(ins, options)
         end
       end
 
@@ -105,6 +107,230 @@ module OrigenTesters
 
       def bin(number, options = {})
       end
+
+      # Assign relevant pins for pinmap sheet generation
+      def pinmap(name, options = {})
+        pinmap = pinmaps("#{name}")
+        Origen.top_level.add_pin_group :JTAG, :tdi, :tdo, :tms
+        Origen.top_level.power_pin_groups.keys.each do |grp_key|
+          pinmap.add_power_pin(grp_key, type: 'Power', comment: "# #{grp_key}")
+        end
+        Origen.top_level.virtual_pins.keys.each do |util_pin|
+          upin = Origen.top_level.virtual_pins(util_pin)
+          case upin.type
+          when :virtual_pin
+            pinmap.add_utility_pin(upin.name, type: 'Utility', comment: "# #{util_pin}")
+          when :ate_ch
+            pinmap.add_utility_pin(upin.name, type: 'I/O', comment: "# #{util_pin}")
+          end
+        end
+        Origen.top_level.pin.keys.each do |pkey|
+          pinmap.add_pin(Origen.top_level.pin(pkey).name, type: 'I/O', comment: "# #{pkey}")
+        end
+        Origen.top_level.pin_groups.keys.sort.each do |gkey|
+          # Do not include pins that are aliased to themselves
+          Origen.top_level.pin(gkey).each do |pin|
+            pinmap.add_group_pin(gkey, Origen.top_level.pin(pin.id).name, type: 'I/O', comment: "# #{gkey}")
+          end
+        end
+      end
+
+      # Assign relevant edges in preparation for edgeset/timeset sheet generation
+      def edge(category, pin, options = {})
+        options = {
+          d_src:   'PAT',     # source of the channel drive data (e.g. pattern, drive_hi, drive_lo, etc.)
+          d_fmt:   'NR',      # drive data format (NR, RL, RH, etc.)
+          d0_edge: '',        # time at which the input drive is turned on
+          d1_edge: '',        # time of the initial data drive edge
+          d2_edge: '',        # time of the return format data drive edge
+          d3_edge: '',        # time at which the input drive is turned off
+          c_mode:  'Edge',    # output compare mode
+          c1_edge: '',        # time of the initial output compare edge
+          c2_edge: '',        # time of the final output compare edge (window compare)
+          t_res:   'Machine', # timing resolution (possibly ATE-specific)
+          clk_per: ''         # clock period equation - for use with MCG
+        }.merge(options)
+
+        @edge_collection = edges
+        @edge_collection.add(category, pin, options)
+      end
+
+      def edge_collection
+        @edge_collection
+      end
+
+      def edgeset(sheet_name, options = {})
+        options = {
+          edgeset: :es_default,
+          period:  'cycle',        # tester cycle period
+          t_mode:  'Machine'       # edgeset timing mode (possibly ATE-specific)
+        }.merge(options)
+        edgeset = options.delete(:edgeset)
+        pin = options.delete(:pin)
+        edge = options.delete(:edge)
+
+        @edgeset = edgesets(sheet_name)
+        @edgeset.add(edgeset, pin, edge, options)
+        collect_ac_specs(@edgeset.es[edgeset].spec_sheet, edge)
+      end
+
+      def timeset(sheet_name, options = {})
+        options = {
+          timeset:   :default,
+          master_ts: :default
+        }.merge(options)
+        timeset = options.delete(:timeset)
+        pin = options.delete(:pin)
+        eset = options.delete(:eset)
+
+        @timeset = timesets(sheet_name)
+        @timeset.add(timeset, pin, eset, options)
+      end
+
+      def ac_specset(sheet_name, expression, options = {})
+        options = {
+          specset: :default,
+          nom:     { typ:  nil }
+        }.merge(options)
+
+        ss = ac_specsets(sheet_name)
+        add_ac_specs(ss, expression, options)
+      end
+
+      # Collects AC Spec object(s) from the given expression and adds them to the given Specset
+      def collect_ac_specs(ssname, edge, options = {})
+        options = {
+          nom: { typ:  nil }
+        }.merge(options)
+
+        # Create a Specsets object from the UFlex program generator API
+        ss = ac_specsets(ssname.to_sym)
+        add_ac_specs(ss, edge.clk_per, options)
+        add_ac_specs(ss, edge.d0_edge, options)
+        add_ac_specs(ss, edge.d1_edge, options)
+        add_ac_specs(ss, edge.d2_edge, options)
+        add_ac_specs(ss, edge.d3_edge, options)
+        add_ac_specs(ss, edge.c1_edge, options)
+        add_ac_specs(ss, edge.c2_edge, options)
+      end
+
+      # Adds new AC Spec object(s) to the given Specset
+      def add_ac_specs(ss, expression, options = {})
+        options = {
+          specset: :default
+        }.merge(options)
+
+        return unless expression.is_a? String
+        # collect all variable names within the expression
+        vars = expression.scan(/[a-zA-Z][\w]+/).map(&:to_sym)
+        vars.each do |var|
+          next if var =~ /^(d0_edge|d1_edge|d2_edge|d3_edge|c1_edge|c2_edge)$/
+          # The substitutions below are used for backward compatibility
+          next if var =~ /^(d_on|d_data|d_ret|d_off|c_open|c_close)$/
+          next if var =~ /^(nS|uS|mS|S)$/i
+          next if ss.ac_specsets.key?(options[:specset]) && ss.ac_specsets[options[:specset]].include?(var)
+
+          ss.add(var, options)
+        end
+      end
+
+      # Assign relevant power supply levels in preparation for levelset sheet generation
+      def pwr_level(category, options = {})
+        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)
+
+        @level_collection = levels
+        @level_collection.add_power_level(category, options)
+      end
+
+      # Assign relevant single-ended pin levels in preparation for levelset sheet generation
+      def pin_level_se(category, options = {})
+        options = {
+          vil:       0,            # Input drive low
+          vih:       1.8,            # Input drive high
+          vol:       1.0,            # Output compare low
+          voh:       0.8,            # Output compare high
+          vcl:       -1,            # Voltage clamp low
+          vch:       2.5,            # Voltage clamp high
+          vt:        0.9,            # Termination voltage
+          voutlotyp: 0,            #
+          vouthityp: 0,            #
+          dmode:     'Largeswing-VT' # Driver mode
+        }.merge(options)
+
+        @level_collection = levels
+        @level_collection.add_se_pin_level(category, options)
+      end
+
+      def level_collection
+        @level_collection
+      end
+
+      def levelset(sheet_name, options = {})
+        pin = options.delete(:pin)
+        level = options.delete(:level)
+
+        @levelset = levelsets(sheet_name)
+        @levelset.add(sheet_name, pin, level, options)
+        collect_dc_specs(@levelset.spec_sheet, level)
+      end
+
+      def dc_specset(sheet_name, expression, options = {})
+        options = {
+          min: { min:  nil },
+          nom: { typ:  nil },
+          max: { max:  nil }
+        }.merge(options)
+
+        ss = dc_specsets(sheet_name.to_sym)
+        add_dc_specs(ss, expression, options)
+      end
+
+      # Collects DC Spec object(s) from the given expression and adds them to the given Specset
+      def collect_dc_specs(ssname, level, options = {})
+        options = {
+          nom: { typ:  nil },
+          min: { min:  nil },
+          max: { max:  nil }
+        }.merge(options)
+
+        # Create a Specsets object from the UFlex program generator API
+        ss = dc_specsets(ssname.to_sym)
+        if level.respond_to?(:vmain)
+          add_dc_specs(ss, level.vmain, options)
+          add_dc_specs(ss, level.valt, options)
+          add_dc_specs(ss, level.ifold, options)
+        elsif level.respond_to?(:vil)
+          add_dc_specs(ss, level.vil, options)
+          add_dc_specs(ss, level.vih, options)
+          add_dc_specs(ss, level.vol, options)
+          add_dc_specs(ss, level.voh, options)
+          add_dc_specs(ss, level.vcl, options)
+          add_dc_specs(ss, level.vch, options)
+          add_dc_specs(ss, level.vt, options)
+          add_dc_specs(ss, level.voutlotyp, options)
+          add_dc_specs(ss, level.vouthityp, options)
+        end
+      end
+
+      # Adds new DC Spec object(s) to the given Specset
+      def add_dc_specs(ss, expression, options = {})
+        options = {
+          specset: :default
+        }.merge(options)
+
+        return unless expression.is_a? String
+        vars = expression.scan(/[a-zA-Z][\w]+/).map(&:to_sym)
+        vars.each do |var|
+          next if var =~ /^(nA|uA|mA|A|nV|uV|mV|V)$/i
+
+          ss.add(var, options)
+        end
+      end
     end
   end
 end

data/lib/origen_testers/test/v93k_interface.rb

@@ -9,7 +9,7 @@ module OrigenTesters
       end
 
       def log(msg)
-        flow.print_to_datalog(msg)
+        flow.log(msg)
       end
 
       def func(name, options = {})
@@ -17,12 +17,12 @@ module OrigenTesters
           duration: :static
         }.merge(options)
 
-        block_loop(name, options) do |block, i, group|
+        block_loop(name, options) do |block, i|
           tm = test_methods.ac_tml.ac_test.functional_test
           ts = test_suites.run(name, options)
           ts.test_method = tm
           ts.levels = options.delete(:pin_levels) if options[:pin_levels]
-          if group
+          if block
             ts.pattern = "#{name}_b#{i}"
           else
             ts.pattern = name.to_s
@@ -68,9 +68,9 @@ module OrigenTesters
 
       def block_loop(name, options)
         if options[:by_block]
-          flow.group name, options do |group|
+          flow.group name, options do
             $dut.blocks.each_with_index do |block, i|
-              yield block, i, group
+              yield block, i
             end
           end
         else
@@ -89,27 +89,9 @@ module OrigenTesters
         # print "UltraFLEX Parametric Test not yet supported for UltraFLEX!\n"
       end
 
-      # OR 2 IDS together into 1 flag
-      # def or_ids(options = {})
-      #  flow.or_flags(options[:id1], options[:id2], options)
-      # end
-
-      def nop(options = {})
-        # flow.nop options
-      end
-
       def mto_memory(name, options = {})
         # Seriously?!
       end
-
-      # OR 2 IDS together into 1 flag
-      def or_ids(options = {})
-        # Eh?
-      end
-
-      def bin(number, options = {})
-        flow.good_bin(number, bin_desc: options[:description])
-      end
     end
   end
 end

data/program/components/_temp.rb

@@ -0,0 +1,6 @@
+Flow.create do |options|
+
+  meas :bgap_voltage_meas, tnum: 1050, bin: 119, soft_bin: 2, hi_limit: 45
+  meas :bgap_voltage_meas1
+
+end

data/program/flow_control.rb

@@ -51,18 +51,6 @@ Flow.create do
     func :read0
   end
 
-  log "Test that skip works"
-  skip do
-    func :read0
-    func :read0
-  end
-
-  log "Test that conditional skip works"
-  skip if_passed: :t4 do
-    func :read0
-    func :read0
-  end
-
   log "Test that if_job works"
   func :cold_test, if_job: :fc
 
@@ -99,66 +87,206 @@ Flow.create do
     func :long_test2
   end
 
-  if $tester.v93k?
-    log "Test that an id can be assigned to a test group"
-    func :read1, id: :r1, bin: 10, by_block: true
-    func :erase1, if_failed: :r1
+  log "Test that if_any_failed works"
+  func :test1, id: :ifa1
+  func :test2, id: :ifa2
+  func :test3, if_any_failed: [:ifa1, :ifa2]
+
+  log "Test the block form of if_any_failed"
+  func :test1, id: :oof_passcode1
+  func :test2, id: :oof_passcode2
+  if_any_failed :oof_passcode1, :oof_passcode2 do
+    func :test3
+    func :test4
+  end
+
+  log "Test that if_all_failed works"
+  func :test1, id: :ifall1
+  func :test2, id: :ifall2
+  func :test3, if_all_failed: [:ifall1, :ifall2]
+
+  log "Test the block form of if_all_failed"
+  func :test1, id: :ifallb1
+  func :test2, id: :ifallb2
+  if_all_failed [:ifallb1, :ifallb2] do
+    func :test3
+    func :test4
+  end
+
+  log "Test that if_any_passed works"
+  func :test1, id: :ifap1
+  func :test2, id: :ifap2
+  func :test3, if_any_passed: [:ifap1, :ifap2]
+
+  log "Test the block form of if_any_passed"
+  func :test1, id: :ifapb1
+  func :test2, id: :ifapb2
+  if_any_passed :ifapb1, :ifapb2 do
+    func :test3
+    func :test4
+  end
+
+  log "Test that if_all_passed works"
+  func :test1, id: :ifallp1
+  func :test2, id: :ifallp2
+  func :test3, if_all_passed: [:ifallp1, :ifallp2]
+
+  log "Test the block form of if_all_passed"
+  func :test1, id: :ifallpb1
+  func :test2, id: :ifallpb2
+  if_all_passed :ifallpb1, :ifallpb2 do
+    func :test3
+    func :test4
+  end
+
+  log "Test that group-level dependencies work"
+  group "grp1", id: :grp1 do
+    func :grp1_test1, bin: 5
+    func :grp1_test2, bin: 5
+    func :grp1_test3, bin: 5
+  end
+
+  group "grp2", if_failed: :grp1 do
+    func :grp2_test1, bin: 5
+    func :grp2_test2, bin: 5
+    func :grp2_test3, bin: 5
+  end
+
+  log "Another group-level dependencies test based on a real life use case"
+  func :gt1, bin: 90
+  group "gt_grp1", id: :gt_grp1 do
+    func :gt_grp1_test1, bin: 90, id: :gt_grp1
+    func :gt_grp1_test2, bin: 90, id: :gt_grp1
+  end
+  func :gt2, bin: 90, if_failed: :gt_grp1
+  group "gt_grp2", id: :gt_grp2, if_failed: :gt_grp1 do
+    # The if_failed and IDs here are redundant, but it should still generate
+    # valid output if an application were to do this
+    func :gt_grp2_test1, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
+    func :gt_grp2_test2, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
+  end
+  func :gt3, bin: 90, if_failed: :gt_grp2
 
-    log "Test that group-level dependencies work"
-    group "grp1", id: :grp1 do
-      func :grp1_test1, bin: 5
-      func :grp1_test2, bin: 5
-      func :grp1_test3, bin: 5
+  log "Test that nested groups work"
+  group "level1" do
+    func :lev1_test1, bin: 5
+    func :lev1_test2, bin: 5
+    func :lev1_test3, id: :l1t3, bin: 10
+    func :lev1_test4, if_failed: :l1t3, bin: 12
+    func :lev1_test5, id: :l1t5, bin: 12
+    group "level2" do
+      func :lev2_test1, bin: 5
+      func :lev2_test2, bin: 5
+      func :lev2_test3, id: :l2t3, bin: 10
+      func :lev2_test4, if_failed: :l2t3, bin: 12
+      # Test dependency on a test from another group
+      func :lev2_test5, if_failed: :l1t5, bin: 12
     end
+  end
 
-    group "grp2", if_failed: :grp1 do
-      func :grp2_test1, bin: 5
-      func :grp2_test2, bin: 5
-      func :grp2_test3, bin: 5
+  log "Test nested conditions on a group"
+  func :nt1, bin: 10, id: :nt1
+  if_failed :nt1 do
+    func :nt2, bin: 11, id: :nt2
+    group "ntg1", id: :ntg1, if_passed: :nt2 do
+      func :nt3, bin: 12
     end
+    group "ntg2", id: :ntg2, if_failed: :nt2 do
+      func :nt4, bin: 13
+    end
+  end
 
-    log "Another group-level dependencies test based on a real life use case"
-    func :gt1, bin: 90
-    group "gt_grp1", id: :gt_grp1 do
-      func :gt_grp1_test1, bin: 90, id: :gt_grp1
-      func :gt_grp1_test2, bin: 90, id: :gt_grp1
+  log "Embedded conditional tests 1"
+  func :test1, id: :ect1_1
+  if_failed :ect1_1 do
+    func :test2
+    func :test3, id: :ect1_3
+    if_failed :ect1_3 do
+      func :test4
     end
-    func :gt2, bin: 90, if_failed: :gt_grp1
-    group "gt_grp2", id: :gt_grp2, if_failed: :gt_grp1 do
-      # The if_failed and IDs here are redundant, but it should still generate
-      # valid output if an application were to do this
-      func :gt_grp2_test1, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
-      func :gt_grp2_test2, bin: 90, id: :gt_grp2, if_failed: :gt_grp1
+  end
+
+  log "Embedded conditional tests 2"
+  func :test1, id: :ect2_1
+  func :test2, id: :ect2_2
+  if_failed :ect2_1 do
+    func :test3, if_failed: :ect2_2
+    func :test4, if_enable: "en1"
+    if_enable "en2" do
+      func :test5
+      func :test6
     end
-    func :gt3, bin: 90, if_failed: :gt_grp2
-
-    log "Test that nested groups work"
-    group "level1" do
-      func :lev1_test1, bin: 5
-      func :lev1_test2, bin: 5
-      func :lev1_test3, id: :l1t3, bin: 10
-      func :lev1_test4, if_failed: :l1t3, bin: 12
-      func :lev1_test5, id: :l1t5, bin: 12
-      group "level2" do
-        func :lev2_test1, bin: 5
-        func :lev2_test2, bin: 5
-        func :lev2_test3, id: :l2t3, bin: 10
-        func :lev2_test4, if_failed: :l2t3, bin: 12
-        # Test dependency on a test from another group
-        func :lev2_test5, if_failed: :l1t5, bin: 12
-      end
+    func :test7
+  end
+  func :test8
+
+  log "Nested enable word test 1"
+  if_enable "word1" do
+    func :test1
+    if_enable "word2" do
+      func :test2
     end
+  end
 
-    log "Test nested conditions on a group"
-    func :nt1, bin: 10, id: :nt1
-    if_failed :nt1 do
-      func :nt2, bin: 11, id: :nt2
-      group "ntg1", id: :ntg1, if_passed: :nt2 do
-        func :nt3, bin: 12
-      end
-      group "ntg2", id: :ntg2, if_failed: :nt2 do
-        func :nt4, bin: 13
+  log "Nested enable word test 2"
+  if_enable "word1" do
+    func :test1
+    unless_enable "word2" do
+      func :test2
+    end
+  end
+
+  log "Nested enable word test 3"
+  if_enable ["word1", "word2"] do
+    func :test1
+    if_enable "word3" do
+      func :test2
+    end
+  end
+
+  log "Conditional enable test"
+  enable :nvm_minimum_ft, if_enable: "nvm_minimum_room", if_job: :fr
+  enable :nvm_minimum_ft, if_enable: "nvm_minimum_cold", if_job: :fc
+  disable :nvm_minimum_ft, if_enable: "nvm_minimum_hot", if_job: :fh
+
+  log "Test enable words that wrap a lot of tests"
+  if_enable :word1 do
+    5.times do
+      func :test1
+    end
+    if_enable :word2 do
+      4.times do
+        func :test1
       end
+      func :test1, enable: :word3
     end
   end
+
+  if tester.j750?
+    log "This should generate an AND flag"
+    func :test1, id: :at1
+    func :test2, id: :at2
+    if_failed :at1 do
+      func :test3, if_failed: :at2
+      # This should re-use the AND flag, rather than create a duplicate
+      func :test4, if_failed: :at2
+    end 
+    log "This should NOT generate an AND flag"
+    # Creating an AND flag here is logically correct, but creates un-necessary flow lines. Since
+    # the test at11 is already gated by the at21 condition, it does not need to be applied to any
+    # tests that are dependent on at11.
+    func :test1, id: :at11
+    if_failed :at11 do
+      func :test2, id: :at21
+      func :test3, if_failed: :at21
+      func :test4, if_failed: :at21
+    end 
+  end
+
+  log "Manual flag setting"
+  test :test1, on_fail: { set_flag: :my_flag }, continue: true
+  test :test2, if_flag: :my_flag
+  unless_flag :my_flag do
+    test :test3
+  end
 end