origen_testers 0.13.1 → 0.13.2

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

@@ -1,37 +1,37 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class TestInstances
-        # Custom Test Instance library
-        class CustomTil
-          # Returns the test_instances object for the current flow
-          attr_reader :test_instances
-          attr_reader :definitions
-
-          def initialize(test_instances, definitions)
-            @test_instances = test_instances
-            @definitions = definitions
-          end
-
-          def method_missing(method, *args, &block)
-            if definitions[method]
-              name = args.shift
-              ti = platform::CustomTestInstance.new name, methods: definitions[method].dup,
-                                                          attrs:   (args.first || {}),
-                                                          type:    method,
-                                                          library: self
-              test_instances.add(nil, ti)
-              ti
-            else
-              super
-            end
-          end
-
-          def platform
-            test_instances.platform
-          end
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class TestInstances
+        # Custom Test Instance library
+        class CustomTil
+          # Returns the test_instances object for the current flow
+          attr_reader :test_instances
+          attr_reader :definitions
+
+          def initialize(test_instances, definitions)
+            @test_instances = test_instances
+            @definitions = definitions
+          end
+
+          def method_missing(method, *args, &block)
+            if definitions[method]
+              name = args.shift
+              ti = platform::CustomTestInstance.new name, methods: definitions[method].dup,
+                                                          attrs:   (args.first || {}),
+                                                          type:    method,
+                                                          library: self
+              test_instances.add(nil, ti)
+              ti
+            else
+              super
+            end
+          end
+
+          def platform
+            test_instances.platform
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -1,49 +1,49 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class Timesets
-        include ::OrigenTesters::Generator
-
-        attr_accessor :ts
-        attr_accessor :ts_sheet_pins
-        attr_accessor :ts_basic
-
-        OUTPUT_PREFIX = 'TS'
-        # OUTPUT_POSTFIX = 'TS'
-
-        def initialize(options = {}) # :nodoc:
-          @ts       = {}
-          @ts_basic = options[:timeset_basic]
-        end
-
-        def add(tsname, pin, esname, options = {})
-          tsname = tsname.to_sym unless tsname.is_a? Symbol
-          pin = pin.to_sym unless pin.is_a? Symbol
-          esname = pin.to_sym unless esname.is_a? Symbol
-          @ts.key?(tsname) ? @ts[tsname].add_edge(pin, esname) : @ts[tsname] = platform::Timeset.new(tsname, pin, esname, options)
-          @ts_sheet_pins = options[:ts_sheet_pins] unless @ts_sheet_pins
-          @ts[tsname]
-        end
-
-        def finalize(options = {})
-        end
-
-        # Populate an array of pins based on the pin or pingroup
-        def get_pin_objects(grp)
-          pins = []
-          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
-             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
-            pins << Origen.top_level.pin(grp)
-          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
-            Origen.top_level.pin(grp).each do |pin|
-              pins << pin
-            end
-          else
-            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
-          end
-          pins
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class Timesets
+        include ::OrigenTesters::Generator
+
+        attr_accessor :ts
+        attr_accessor :ts_sheet_pins
+        attr_accessor :ts_basic
+
+        OUTPUT_PREFIX = 'TS'
+        # OUTPUT_POSTFIX = 'TS'
+
+        def initialize(options = {}) # :nodoc:
+          @ts       = {}
+          @ts_basic = options[:timeset_basic]
+        end
+
+        def add(tsname, pin, esname, options = {})
+          tsname = tsname.to_sym unless tsname.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+          esname = pin.to_sym unless esname.is_a? Symbol
+          @ts.key?(tsname) ? @ts[tsname].add_edge(pin, esname) : @ts[tsname] = platform::Timeset.new(tsname, pin, esname, options)
+          @ts_sheet_pins = options[:ts_sheet_pins] unless @ts_sheet_pins
+          @ts[tsname]
+        end
+
+        def finalize(options = {})
+        end
+
+        # Populate an array of pins based on the pin or pingroup
+        def get_pin_objects(grp)
+          pins = []
+          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
+             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
+            pins << Origen.top_level.pin(grp)
+          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
+            Origen.top_level.pin(grp).each do |pin|
+              pins << pin
+            end
+          else
+            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
+          end
+          pins
+        end
+      end
+    end
+  end
+end

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

@@ -1,49 +1,49 @@
-module OrigenTesters
-  module IGXLBasedTester
-    class Base
-      class TimesetsBasic
-        include ::OrigenTesters::Generator
-
-        attr_accessor :ts
-        attr_accessor :ts_sheet_pins
-        attr_accessor :ts_basic
-
-        OUTPUT_PREFIX = 'TSB'
-        # OUTPUT_POSTFIX = 'TS'
-
-        def initialize(options = {}) # :nodoc:
-          @ts       = {}
-          @ts_basic = options[:timeset_basic]
-        end
-
-        def add(tsname, pin, esname, options = {})
-          tsname = tsname.to_sym unless tsname.is_a? Symbol
-          pin = pin.to_sym unless pin.is_a? Symbol
-          esname = pin.to_sym unless esname.is_a? Symbol
-          @ts.key?(tsname) ? @ts[tsname].add_edge(pin, esname) : @ts[tsname] = platform::Timeset.new(tsname, pin, esname, options)
-          @ts_sheet_pins = options[:ts_sheet_pins] unless @ts_sheet_pins
-          @ts[tsname]
-        end
-
-        def finalize(options = {})
-        end
-
-        # Populate an array of pins based on the pin or pingroup
-        def get_pin_objects(grp)
-          pins = []
-          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
-             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
-            pins << Origen.top_level.pin(grp)
-          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
-            Origen.top_level.pin(grp).each do |pin|
-              pins << pin
-            end
-          else
-            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
-          end
-          pins
-        end
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    class Base
+      class TimesetsBasic
+        include ::OrigenTesters::Generator
+
+        attr_accessor :ts
+        attr_accessor :ts_sheet_pins
+        attr_accessor :ts_basic
+
+        OUTPUT_PREFIX = 'TSB'
+        # OUTPUT_POSTFIX = 'TS'
+
+        def initialize(options = {}) # :nodoc:
+          @ts       = {}
+          @ts_basic = options[:timeset_basic]
+        end
+
+        def add(tsname, pin, esname, options = {})
+          tsname = tsname.to_sym unless tsname.is_a? Symbol
+          pin = pin.to_sym unless pin.is_a? Symbol
+          esname = pin.to_sym unless esname.is_a? Symbol
+          @ts.key?(tsname) ? @ts[tsname].add_edge(pin, esname) : @ts[tsname] = platform::Timeset.new(tsname, pin, esname, options)
+          @ts_sheet_pins = options[:ts_sheet_pins] unless @ts_sheet_pins
+          @ts[tsname]
+        end
+
+        def finalize(options = {})
+        end
+
+        # Populate an array of pins based on the pin or pingroup
+        def get_pin_objects(grp)
+          pins = []
+          if Origen.top_level.pin(grp).is_a?(Origen::Pins::Pin) ||
+             Origen.top_level.pin(grp).is_a?(Origen::Pins::FunctionProxy)
+            pins << Origen.top_level.pin(grp)
+          elsif Origen.top_level.pin(grp).is_a?(Origen::Pins::PinCollection)
+            Origen.top_level.pin(grp).each do |pin|
+              pins << pin
+            end
+          else
+            Origen.log.error "Could not find pin class: #{grp}  #{Origen.top_level.pin(grp).class}"
+          end
+          pins
+        end
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/files.rb

@@ -1,43 +1,43 @@
-module OrigenTesters
-  module IGXLBasedTester
-    # Methods for handling all J750 file parsing, e.g. datalogs,
-    # test time profiles, etc.
-    module Files
-      # Reads all lines from a J750 detailed execution time file, returning the lines
-      # as an array like this:
-      #
-      #   [
-      #     {:name => "power_cycle", :index => 1, :group => 3, :time => 0.00461},
-      #     {:name => "power_cycle", :index => 2, :group => 3, :time => 0.00481},
-      #     {:name => "power_cycle", :index => 3, :group => 3, :time => 0.00438},
-      #     {:name => "nvm_mass_erase", :index => nil, :group => nil, :time => 0.19863},
-      #   ]
-      def read_test_times(file, options = {})
-        tests = []
-        File.readlines(file).each do |line|
-          unless line.strip.empty? || line =~ /Entire Job/
-            # http://rubular.com/r/vZOcqovTsf
-            if line =~ /(\w+) ?(\(.*?\))?  \d\d\d\d  (\d+\.\d+).*/
-              t = { name: Regexp.last_match[1], time: Regexp.last_match[3].to_f.round(6) }
-              # If an indexed test
-              if Regexp.last_match[2]
-                str = Regexp.last_match[2].gsub('(', '').gsub(')', '')
-                fields = str.split('/')
-                i = fields[0].to_i
-                g = fields[1].to_i
-                t[:index] = i
-                t[:group] = g
-
-              else
-                t[:index] = nil
-                t[:group] = nil
-              end
-              tests << t
-            end
-          end
-        end
-        tests
-      end
-    end
-  end
-end
+module OrigenTesters
+  module IGXLBasedTester
+    # Methods for handling all J750 file parsing, e.g. datalogs,
+    # test time profiles, etc.
+    module Files
+      # Reads all lines from a J750 detailed execution time file, returning the lines
+      # as an array like this:
+      #
+      #   [
+      #     {:name => "power_cycle", :index => 1, :group => 3, :time => 0.00461},
+      #     {:name => "power_cycle", :index => 2, :group => 3, :time => 0.00481},
+      #     {:name => "power_cycle", :index => 3, :group => 3, :time => 0.00438},
+      #     {:name => "nvm_mass_erase", :index => nil, :group => nil, :time => 0.19863},
+      #   ]
+      def read_test_times(file, options = {})
+        tests = []
+        File.readlines(file).each do |line|
+          unless line.strip.empty? || line =~ /Entire Job/
+            # http://rubular.com/r/vZOcqovTsf
+            if line =~ /(\w+) ?(\(.*?\))?  \d\d\d\d  (\d+\.\d+).*/
+              t = { name: Regexp.last_match[1], time: Regexp.last_match[3].to_f.round(6) }
+              # If an indexed test
+              if Regexp.last_match[2]
+                str = Regexp.last_match[2].gsub('(', '').gsub(')', '')
+                fields = str.split('/')
+                i = fields[0].to_i
+                g = fields[1].to_i
+                t[:index] = i
+                t[:group] = g
+
+              else
+                t[:index] = nil
+                t[:group] = nil
+              end
+              tests << t
+            end
+          end
+        end
+        tests
+      end
+    end
+  end
+end

data/lib/origen_testers/igxl_based_tester/j750.rb

@@ -1,269 +1,269 @@
-module OrigenTesters
-  module IGXLBasedTester
-    # Tester model to generate .atp patterns for the Teradyne J750
-    #
-    # == Basic Usage
-    #   $tester = Testers::J750.new
-    #   $tester.cycle       # Generate a vector
-    #
-    # Many more methods exist to generate J750 specific micro-code, see below for
-    # details.
-    #
-    # Also note that this class inherits from the base Tester class and so all methods
-    # described there are also available.
-    class J750 < Base
-      require 'origen_testers/igxl_based_tester/j750/generator.rb'
-
-      attr_accessor :use_hv_pin
-      attr_accessor :software_version
-
-      def self.hpt_mode
-        @@hpt_mode
-      end
-      def self.hpt_mode?
-        @@hpt_mode
-      end
-
-      # Returns a new J750 instance, normally there would only ever be one of these
-      # assigned to the global variable such as $tester by your target.
-      def initialize
-        super
-        @pipeline_depth = 34  # for extended mode is vectors, for normal mode is vector pairs (54 for J750Ex)
-        @use_hv_pin = false   # allows to use high voltage for a pin for all patterns
-        @software_version = '3.50.40'
-        @name = 'j750'
-        @@hpt_mode = false
-        @opcode_mode = :extended
-        @loop_bits_max = 16             # maximum loop bit length
-
-        @flags = %w(cpuA cpuB cpuC cpuD)
-        @microcode[:enable] = 'enable'
-        @microcode[:set_flag] = 'set_cpu'
-        @microcode[:mask_vector] = 'ign ifc icc'
-        @microcode[:keepalive] = 'keep_alive'
-      end
-
-      def pattern_header(options = {})
-        super(options) do |pin_list|
-          microcode "vector ($tset, #{pin_list})"
-          microcode '{'
-          unless options[:subroutine_pat]
-            microcode 'start_label pattern_st:'
-          end
-        end
-      end
-
-      def pattern_footer(options = {})
-        super(options)
-      end
-
-      # Generates a match loop based on vector condition passed in via block
-      #
-      # This method is not really intended to be called directly, rather you should call
-      # via Tester#wait:
-      #      e.g. $tester.wait(:match => true) do
-      #             reg(:status_reg).bit(:done).read(1)!  # vector condition that you want to match
-      #           end
-      #
-      # The timeout should be provided in cycles, however when called via the wait method the
-      # time-based helpers (time_in_us, etc) will be converted to cycles for you.
-      #
-      # The following options are available to tailor the match loop behavior, defaults in
-      # parenthesis:
-      # * :check_for_fails (false) - Flushes the pipeline and handshakes with the tester (passing readcode 100) prior to the match (to allow binout of fails encountered before the match)
-      # * :force_fail_on_timeout (true) - Force a vector mis-compare if the match loop times out
-      # * :on_timeout_goto ("") - Optionally supply a label to branch to on timeout, by default will continue from the end of the match loop
-      # * :on_block_match_goto ("") - Optionally supply a label to branch to when block condition is met, by default will continue from the end of the match loop.
-      #   A hash will also be accepted for this argument to supply a specific label (or no label) for each block e.g. {0 => "on_block_0_fail"}
-      # * :multiple_entries (false) - Supply an integer to generate multiple entries into the match (each with a unique readcode), this can be useful when debugging patterns with multiple matches
-      # * :force_fail_on_timeout (true) - force pattern to fail if timeout occurs
-      # * :global_loops (false) - whether match loop loops should use global labels
-      # * :manual_stop (false) - whether to use extra cpuB flag to resolve IG-XL v.3.50.xx bug where VBT clears cpuA immediately
-      #                          at start of PatFlagFunc instead of at end.  Use will have to manually clear cpuB to resume this pattern.
-      # ==== Examples
-      #   $tester.wait(:match => true, :time_in_us => 5000, :pin => $top.pin(:done), :state => :high) do
-      #     <vectors>
-      #   end
-      def match_block(timeout, options = {}, &block)
-        options = {
-          check_for_fails:       false,
-          on_timeout_goto:       false,
-          on_block_match_goto:   false,
-          multiple_entries:      false,
-          force_fail_on_timeout: true,
-          global_loops:          false,
-          manual_stop:           false,
-          clr_fail_post_match:   false
-        }.merge(options)
-
-        unless block_given?
-          fail 'ERROR: block not passed to match_block!'
-        end
-
-        # Create BlockArgs objects in order to receive multiple blocks
-        match_conditions = Origen::Utility::BlockArgs.new
-        fail_conditions = Origen::Utility::BlockArgs.new
-
-        # yield object to calling routine to get populated with blocks
-        if block.arity > 0
-          yield match_conditions, fail_conditions
-        else
-          # for backwards compatibility with Origen core call to match_block
-          match_conditions.add(&block)
-          fail_conditions.add(&block)
-        end
-
-        # Flush the pipeline first and then pass control to the program to bin out any failures
-        # prior to entering the match loop
-        if options[:check_for_fails]
-          if options[:multiple_entries]
-            @match_entries.times do |i|
-              microcode "global subr match_done_#{i}:"
-              set_code(i + 100)
-              cycle(microcode: 'jump call_tester') unless i == @match_entries - 1
-            end
-            microcode 'call_tester:'
-          else
-            set_code(100)
-          end
-          cc 'Wait for any prior failures to propagate through the pipeline'
-          cycle(microcode: 'pipe_minus 1')
-          cc 'Now handshake with the tester to bin out and parts that have failed before they got here'
-          handshake(manual_stop: options[:manual_stop])
-        end
-
-        # Now do the main match loop
-        cc 'Start the match loop'
-
-        global_opt = (options[:global_loops]) ? 'global ' : ''
-        microcode "#{global_opt}match_outer_loop_#{@unique_counter}:"
-        cycle # (:microcode => "loopB #{outer_loop_count} ign ifc icc")
-        set_loopb_vector = last_vector
-
-        microcode "#{global_opt}match_inner_loop_#{@unique_counter}:"
-        cycle # (:microcode => "loopA #{inner_loop_count} ign ifc icc")
-        set_loopa_vector = last_vector
-
-        # count cycles in match loop block passed to help with meeting
-        # desired timeout value (have to back assign microcodes above)
-        prematch_cycle_count = cycle_count
-        match_conditions.each_with_index do |condition, i|
-          mask_fails(true)
-          condition.call  # match condition
-          mask_fails(false)
-          cc ' Wait for the result to propagate through the pipeline'
-          cycle(microcode: 'pipe_minus 1 ign ifc icc')
-          inc_cycle_count(@pipeline_depth - 1)                   # Account for pipeline depth
-          cc "Branch if block condition #{i} met"
-          cycle(microcode: "if (pass) jump block_#{i}_matched_#{@unique_counter} icc ifc")
-          cycle(microcode: 'clr_flag (fail) icc')
-        end
-        match_conditions_cycle_count = cycle_count - prematch_cycle_count
-        cc "Match loop cycle count = #{match_conditions_cycle_count}"
-
-        # reduce timeout requested by match loop cycle count
-        timeout = (timeout.to_f / match_conditions_cycle_count).ceil
-
-        # Calculate the loop counts for the 2 loops to appropriately hit the timeout requested
-        loop_value = timeout.to_f.floor
-
-        if loop_value < (2**@loop_bits_max)
-          # small value, only need to use one loop
-          outer_loop_count = 1
-          inner_loop_count = loop_value
-        elsif loop_value < (2**(2 * @loop_bits_max))
-          # 2 nested loops required
-          inner_loop_count = 2**@loop_bits_max - 1
-          outer_loop_count = (loop_value.to_f / inner_loop_count).ceil
-        else
-          abort 'ERROR: timeout value too large in tester match method!'
-        end
-
-        # retroactively set loop counter values for timeout based on cycles in match loop condition
-        set_loopb_vector.microcode = "loopB #{outer_loop_count} ign ifc icc"
-        set_loopa_vector.microcode = "loopA #{inner_loop_count} ign ifc icc"
-
-        cc 'Loop back around if time remaining'
-        cycle(microcode: "end_loopA match_inner_loop_#{@unique_counter} icc")
-        cycle(microcode: "end_loopB match_outer_loop_#{@unique_counter} icc")
-
-        if options[:force_fail_on_timeout]
-          cc 'To get here something has gone wrong, check block again to force a pattern failure'
-          fail_conditions.each(&:call)
-        end
-
-        if options[:on_timeout_goto]
-          cycle(microcode: "jump #{options[:on_timeout_goto]} icc")
-        else
-          cycle(microcode: "jump match_loop_end_#{@unique_counter} icc")
-          # cycle(:microcode => 'halt')
-        end
-        match_conditions.each_with_index do |condition, i|
-          microcode "block_#{i}_matched_#{@unique_counter}:"
-          cycle(microcode: 'pop_loop icc')
-          cycle(microcode: 'clr_fail')
-          if options[:on_block_match_goto]
-            if options[:on_block_match_goto].is_a?(Hash)
-              if options[:on_block_match_goto][i]
-                custom_jump = options[:on_block_match_goto][i]
-              else
-                custom_jump = nil
-              end
-            else
-              custom_jump = options[:on_block_match_goto]
-            end
-          end
-          if custom_jump
-            cycle(microcode: "jump #{custom_jump}")
-          else
-            # Don't do a jump on the last match block as it will naturally fall through
-            # TODO: Update origen core to expose the size
-            unless match_conditions.instance_variable_get(:@block_args).size == i + 1
-              cycle(microcode: "jump match_loop_end_#{@unique_counter} icc")
-            end
-          end
-        end
-        microcode "match_loop_end_#{@unique_counter}:"
-        if options[:clr_fail_post_match]
-          cycle(microcode: 'clr_fail')
-        end
-
-        @unique_counter += 1  # Increment so a different label will be applied if another
-        # handshake is called in the same pattern
-      end
-
-      # Handshake with the tester.
-      #
-      # Will set a cpu flag (A) and wait for it to be cleared by the tester, optionally
-      # pass in a read code to pass information to the tester.
-      #
-      # ==== Examples
-      #   $tester.handshake                   # Pass control to the tester for a measurement
-      #   $tester.handshake(:readcode => 10)  # Trigger a specific action by the tester
-      def handshake(options = {})
-        options = {
-          readcode:    false,
-          manual_stop: false,    # set a 2nd CPU flag in case 1st flag is automatically cleared
-        }.merge(options)
-        if options[:readcode]
-          set_code(options[:readcode])
-        end
-        if options[:manual_stop]
-          cycle(microcode: "#{@microcode[:enable]} (#{@flags[1]})")
-          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]} #{@flags[1]})")
-          cycle(microcode: "loop_here_#{@unique_counter}: if (flag) jump loop_here_#{@unique_counter}")
-        else
-          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]})")
-          cycle(microcode: "loop_here_#{@unique_counter}: if (#{@flags[0]}) jump loop_here_#{@unique_counter}")
-        end
-        @unique_counter += 1  # Increment so a different label will be applied if another
-        # handshake is called in the same pattern
-      end
-
-      def keep_alive(options = {})
-        $tester.cycle microcode: "#{@microcode[:keepalive]}"
-      end
-    end
-  end
-  J750 = IGXLBasedTester::J750
-end
+module OrigenTesters
+  module IGXLBasedTester
+    # Tester model to generate .atp patterns for the Teradyne J750
+    #
+    # == Basic Usage
+    #   $tester = Testers::J750.new
+    #   $tester.cycle       # Generate a vector
+    #
+    # Many more methods exist to generate J750 specific micro-code, see below for
+    # details.
+    #
+    # Also note that this class inherits from the base Tester class and so all methods
+    # described there are also available.
+    class J750 < Base
+      require 'origen_testers/igxl_based_tester/j750/generator.rb'
+
+      attr_accessor :use_hv_pin
+      attr_accessor :software_version
+
+      def self.hpt_mode
+        @@hpt_mode
+      end
+      def self.hpt_mode?
+        @@hpt_mode
+      end
+
+      # Returns a new J750 instance, normally there would only ever be one of these
+      # assigned to the global variable such as $tester by your target.
+      def initialize
+        super
+        @pipeline_depth = 34  # for extended mode is vectors, for normal mode is vector pairs (54 for J750Ex)
+        @use_hv_pin = false   # allows to use high voltage for a pin for all patterns
+        @software_version = '3.50.40'
+        @name = 'j750'
+        @@hpt_mode = false
+        @opcode_mode = :extended
+        @loop_bits_max = 16             # maximum loop bit length
+
+        @flags = %w(cpuA cpuB cpuC cpuD)
+        @microcode[:enable] = 'enable'
+        @microcode[:set_flag] = 'set_cpu'
+        @microcode[:mask_vector] = 'ign ifc icc'
+        @microcode[:keepalive] = 'keep_alive'
+      end
+
+      def pattern_header(options = {})
+        super(options) do |pin_list|
+          microcode "vector ($tset, #{pin_list})"
+          microcode '{'
+          unless options[:subroutine_pat]
+            microcode 'start_label pattern_st:'
+          end
+        end
+      end
+
+      def pattern_footer(options = {})
+        super(options)
+      end
+
+      # Generates a match loop based on vector condition passed in via block
+      #
+      # This method is not really intended to be called directly, rather you should call
+      # via Tester#wait:
+      #      e.g. $tester.wait(:match => true) do
+      #             reg(:status_reg).bit(:done).read(1)!  # vector condition that you want to match
+      #           end
+      #
+      # The timeout should be provided in cycles, however when called via the wait method the
+      # time-based helpers (time_in_us, etc) will be converted to cycles for you.
+      #
+      # The following options are available to tailor the match loop behavior, defaults in
+      # parenthesis:
+      # * :check_for_fails (false) - Flushes the pipeline and handshakes with the tester (passing readcode 100) prior to the match (to allow binout of fails encountered before the match)
+      # * :force_fail_on_timeout (true) - Force a vector mis-compare if the match loop times out
+      # * :on_timeout_goto ("") - Optionally supply a label to branch to on timeout, by default will continue from the end of the match loop
+      # * :on_block_match_goto ("") - Optionally supply a label to branch to when block condition is met, by default will continue from the end of the match loop.
+      #   A hash will also be accepted for this argument to supply a specific label (or no label) for each block e.g. {0 => "on_block_0_fail"}
+      # * :multiple_entries (false) - Supply an integer to generate multiple entries into the match (each with a unique readcode), this can be useful when debugging patterns with multiple matches
+      # * :force_fail_on_timeout (true) - force pattern to fail if timeout occurs
+      # * :global_loops (false) - whether match loop loops should use global labels
+      # * :manual_stop (false) - whether to use extra cpuB flag to resolve IG-XL v.3.50.xx bug where VBT clears cpuA immediately
+      #                          at start of PatFlagFunc instead of at end.  Use will have to manually clear cpuB to resume this pattern.
+      # ==== Examples
+      #   $tester.wait(:match => true, :time_in_us => 5000, :pin => $top.pin(:done), :state => :high) do
+      #     <vectors>
+      #   end
+      def match_block(timeout, options = {}, &block)
+        options = {
+          check_for_fails:       false,
+          on_timeout_goto:       false,
+          on_block_match_goto:   false,
+          multiple_entries:      false,
+          force_fail_on_timeout: true,
+          global_loops:          false,
+          manual_stop:           false,
+          clr_fail_post_match:   false
+        }.merge(options)
+
+        unless block_given?
+          fail 'ERROR: block not passed to match_block!'
+        end
+
+        # Create BlockArgs objects in order to receive multiple blocks
+        match_conditions = Origen::Utility::BlockArgs.new
+        fail_conditions = Origen::Utility::BlockArgs.new
+
+        # yield object to calling routine to get populated with blocks
+        if block.arity > 0
+          yield match_conditions, fail_conditions
+        else
+          # for backwards compatibility with Origen core call to match_block
+          match_conditions.add(&block)
+          fail_conditions.add(&block)
+        end
+
+        # Flush the pipeline first and then pass control to the program to bin out any failures
+        # prior to entering the match loop
+        if options[:check_for_fails]
+          if options[:multiple_entries]
+            @match_entries.times do |i|
+              microcode "global subr match_done_#{i}:"
+              set_code(i + 100)
+              cycle(microcode: 'jump call_tester') unless i == @match_entries - 1
+            end
+            microcode 'call_tester:'
+          else
+            set_code(100)
+          end
+          cc 'Wait for any prior failures to propagate through the pipeline'
+          cycle(microcode: 'pipe_minus 1')
+          cc 'Now handshake with the tester to bin out and parts that have failed before they got here'
+          handshake(manual_stop: options[:manual_stop])
+        end
+
+        # Now do the main match loop
+        cc 'Start the match loop'
+
+        global_opt = (options[:global_loops]) ? 'global ' : ''
+        microcode "#{global_opt}match_outer_loop_#{@unique_counter}:"
+        cycle # (:microcode => "loopB #{outer_loop_count} ign ifc icc")
+        set_loopb_vector = last_vector
+
+        microcode "#{global_opt}match_inner_loop_#{@unique_counter}:"
+        cycle # (:microcode => "loopA #{inner_loop_count} ign ifc icc")
+        set_loopa_vector = last_vector
+
+        # count cycles in match loop block passed to help with meeting
+        # desired timeout value (have to back assign microcodes above)
+        prematch_cycle_count = cycle_count
+        match_conditions.each_with_index do |condition, i|
+          mask_fails(true)
+          condition.call  # match condition
+          mask_fails(false)
+          cc ' Wait for the result to propagate through the pipeline'
+          cycle(microcode: 'pipe_minus 1 ign ifc icc')
+          inc_cycle_count(@pipeline_depth - 1)                   # Account for pipeline depth
+          cc "Branch if block condition #{i} met"
+          cycle(microcode: "if (pass) jump block_#{i}_matched_#{@unique_counter} icc ifc")
+          cycle(microcode: 'clr_flag (fail) icc')
+        end
+        match_conditions_cycle_count = cycle_count - prematch_cycle_count
+        cc "Match loop cycle count = #{match_conditions_cycle_count}"
+
+        # reduce timeout requested by match loop cycle count
+        timeout = (timeout.to_f / match_conditions_cycle_count).ceil
+
+        # Calculate the loop counts for the 2 loops to appropriately hit the timeout requested
+        loop_value = timeout.to_f.floor
+
+        if loop_value < (2**@loop_bits_max)
+          # small value, only need to use one loop
+          outer_loop_count = 1
+          inner_loop_count = loop_value
+        elsif loop_value < (2**(2 * @loop_bits_max))
+          # 2 nested loops required
+          inner_loop_count = 2**@loop_bits_max - 1
+          outer_loop_count = (loop_value.to_f / inner_loop_count).ceil
+        else
+          abort 'ERROR: timeout value too large in tester match method!'
+        end
+
+        # retroactively set loop counter values for timeout based on cycles in match loop condition
+        set_loopb_vector.microcode = "loopB #{outer_loop_count} ign ifc icc"
+        set_loopa_vector.microcode = "loopA #{inner_loop_count} ign ifc icc"
+
+        cc 'Loop back around if time remaining'
+        cycle(microcode: "end_loopA match_inner_loop_#{@unique_counter} icc")
+        cycle(microcode: "end_loopB match_outer_loop_#{@unique_counter} icc")
+
+        if options[:force_fail_on_timeout]
+          cc 'To get here something has gone wrong, check block again to force a pattern failure'
+          fail_conditions.each(&:call)
+        end
+
+        if options[:on_timeout_goto]
+          cycle(microcode: "jump #{options[:on_timeout_goto]} icc")
+        else
+          cycle(microcode: "jump match_loop_end_#{@unique_counter} icc")
+          # cycle(:microcode => 'halt')
+        end
+        match_conditions.each_with_index do |condition, i|
+          microcode "block_#{i}_matched_#{@unique_counter}:"
+          cycle(microcode: 'pop_loop icc')
+          cycle(microcode: 'clr_fail')
+          if options[:on_block_match_goto]
+            if options[:on_block_match_goto].is_a?(Hash)
+              if options[:on_block_match_goto][i]
+                custom_jump = options[:on_block_match_goto][i]
+              else
+                custom_jump = nil
+              end
+            else
+              custom_jump = options[:on_block_match_goto]
+            end
+          end
+          if custom_jump
+            cycle(microcode: "jump #{custom_jump}")
+          else
+            # Don't do a jump on the last match block as it will naturally fall through
+            # TODO: Update origen core to expose the size
+            unless match_conditions.instance_variable_get(:@block_args).size == i + 1
+              cycle(microcode: "jump match_loop_end_#{@unique_counter} icc")
+            end
+          end
+        end
+        microcode "match_loop_end_#{@unique_counter}:"
+        if options[:clr_fail_post_match]
+          cycle(microcode: 'clr_fail')
+        end
+
+        @unique_counter += 1  # Increment so a different label will be applied if another
+        # handshake is called in the same pattern
+      end
+
+      # Handshake with the tester.
+      #
+      # Will set a cpu flag (A) and wait for it to be cleared by the tester, optionally
+      # pass in a read code to pass information to the tester.
+      #
+      # ==== Examples
+      #   $tester.handshake                   # Pass control to the tester for a measurement
+      #   $tester.handshake(:readcode => 10)  # Trigger a specific action by the tester
+      def handshake(options = {})
+        options = {
+          readcode:    false,
+          manual_stop: false,    # set a 2nd CPU flag in case 1st flag is automatically cleared
+        }.merge(options)
+        if options[:readcode]
+          set_code(options[:readcode])
+        end
+        if options[:manual_stop]
+          cycle(microcode: "#{@microcode[:enable]} (#{@flags[1]})")
+          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]} #{@flags[1]})")
+          cycle(microcode: "loop_here_#{@unique_counter}: if (flag) jump loop_here_#{@unique_counter}")
+        else
+          cycle(microcode: "#{@microcode[:set_flag]} (#{@flags[0]})")
+          cycle(microcode: "loop_here_#{@unique_counter}: if (#{@flags[0]}) jump loop_here_#{@unique_counter}")
+        end
+        @unique_counter += 1  # Increment so a different label will be applied if another
+        # handshake is called in the same pattern
+      end
+
+      def keep_alive(options = {})
+        $tester.cycle microcode: "#{@microcode[:keepalive]}"
+      end
+    end
+  end
+  J750 = IGXLBasedTester::J750
+end