origen_testers 0.20.0 → 0.21.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2bb719c179345dee09336e7c9ef743de9383d0bc32602c58226a682607c93016
-  data.tar.gz: 7f98c2c6a7d9639bf70c42d4264ba3294b72b814b3c455e9983d4342c3ade773
+  metadata.gz: fe9e0d79136d4c5a7a16b3e73e098ac9069c0aa0d4efb70e4e9c93bb1b1d01d7
+  data.tar.gz: 115289be29ed7e600ee5e331a61649e05f649131956214bebd81a6afb963a0d7
 SHA512:
-  metadata.gz: 5530008ddd55eb90eb4d6502dc8a61633eb28a88d1eed1baa8e9b51ed52bbd3b274c8fb7bd680318716b6c70d910a40c27c2515134b1ce067e69d6e2fde2fce6
-  data.tar.gz: d599275895db3b446e5f8c3ebe9da2101aa759e8ba622ca5c9a94c14fb12159409f35a1b423df2f6383c70c19136a638c2383a3ce6ac62a2ddb2f48c4f37ca7f
+  metadata.gz: 13b81ab2f3f0c642ba283399fbc39df7f1fcf7f982995f53ae75ef4acef6b060ca196bec8ea9571b65a548831a712eba6653b6eadcd52b5672fd84cad91ff051
+  data.tar.gz: 1ee85240a3d5c559dff37c61f12110f02a1a8228fc36f828911fe7d13c79cfc12fff72d49ead48f7b0ca33ee24fc3263f2f4f357abfd014aad3bb418bb12b0be

data/config/application.rb

@@ -4,6 +4,7 @@ class OrigenTestersApplication < Origen::Application
 
   config.shared = {
     command_launcher: "config/shared_commands.rb",
+    global_launcher: "config/global_commands.rb",
     origen_guides: "templates/origen_guides",
     origen_guides_index: -> (index) do
       index.section :pattern, heading: "Pattern Generator", after: :controllers do |section|
@@ -18,6 +19,7 @@ class OrigenTestersApplication < Origen::Application
         section.page :j750, heading: "J750 API"
         section.page :v93k, heading: "V93K API"
         section.page :ultraflex, heading: "UltraFlex API"
+        section.page :stil, heading: "STIL & Other Formats"
         section.page :custom, heading: "Custom Testers"
         section.page :running, heading: "Running The PatGen"
       end
@@ -84,13 +86,13 @@ class OrigenTestersApplication < Origen::Application
     dir
   end
   
-  # Setting this to the spec area for testing of compiler
-  config.pattern_output_directory do
-   dir = "#{Origen.root}/spec/patterns/atp"
-  # Check if running on windows, if so, substitute :: with _
-   dir.gsub!("::","_") if Origen.os.windows?
-   dir
-  end
+#  config.pattern_output_directory do
+#  # Setting this to the spec area for testing of compiler
+#   dir = "#{Origen.root}/spec/patterns/atp"
+#  # Check if running on windows, if so, substitute :: with _
+#   dir.gsub!("::","_") if Origen.os.windows?
+#   dir
+#  end
 
   # Run the tests before deploying to generate test coverage numbers
   def before_deploy_site

data/config/global_commands.rb

@@ -0,0 +1,12 @@
+case @command
+
+when "convert"
+  require "#{Origen.root!}/lib/commands/convert"
+  exit 0
+
+else
+  @global_commands << <<-EOT
+ convert      Convert a tester pattern from one format to another
+  EOT
+
+end

data/config/version.rb

@@ -1,6 +1,6 @@
 module OrigenTesters
   MAJOR = 0
-  MINOR = 20
+  MINOR = 21
   BUGFIX = 0
   DEV = nil
 

data/lib/commands/convert.rb

@@ -0,0 +1,105 @@
+require 'optparse'
+require 'pathname'
+require 'origen_testers'
+require 'origen_stil'
+
+options = {}
+
+ENVIRONMENTS = {
+  j750:      OrigenTesters::J750,
+  uflex:     OrigenTesters::UltraFLEX,
+  v93k_smt7: OrigenTesters::V93K
+}.with_indifferent_access
+
+opt_parser = OptionParser.new do |opts|
+  if Origen.running_globally?
+    opts.banner = <<-EOT
+Convert the given pattern file to another environment (tester) format.
+
+Usage: origen convert FILE -e v93k_smt7 [options]
+  EOT
+  else
+    opts.banner = <<-EOT
+Convert the given pattern file to another environment (tester) format.
+
+Usage: origen convert FILE [options]
+  EOT
+  end
+  opts.on('-o', '--output DIR', String, 'Override the default output directory') { |t| options[:output] = t }
+  if Origen.running_globally?
+    opts.on('-e', '--environment NAME', ENVIRONMENTS, 'Specify the target environment:', '  ' + ENVIRONMENTS.keys.join(', ')) { |e| options[:environment] = e }
+  else
+    opts.on('-e', '--environment NAME', String, 'Override the default environment, NAME can be a full path or a fragment of an environment file name') { |e| options[:environment] = e }
+    opts.on('-t', '--target NAME', String, 'Override the default target, NAME can be a full path or a fragment of a target file name') { |t| options[:target] = t }
+  end
+  opts.on('-d', '--debugger', 'Enable the debugger') {  options[:debugger] = true }
+  opts.on('-m', '--mode MODE', Origen::Mode::MODES, 'Force the Origen operating mode:', '  ' + Origen::Mode::MODES.join(', ')) { |_m| }
+  opts.separator ''
+  opts.on('-h', '--help', 'Show this message') { puts opts; exit 0 }
+end
+
+opt_parser.parse! ARGV
+
+if Origen.running_globally?
+
+  module OrigenTesters
+    class AnonymousDUT
+      include Origen::TopLevel
+    end
+  end
+
+  unless options[:environment]
+    puts 'You must specify the target environment (tester) via the -e switch with one of the following values:'
+    puts '  ' + ENVIRONMENTS.keys.join(', ')
+    exit 1
+  end
+
+  Origen.target.temporary = lambda do
+    OrigenTesters::AnonymousDUT.new
+    options[:environment].new
+    # Stops the generated pattern being compared to a reference
+    tester.define_singleton_method(:disable_pattern_diffs) { true }
+  end
+else
+
+  Origen.environment.temporary = options[:environment] if options[:environment]
+  Origen.target.temporary = options[:target] if options[:target]
+end
+
+def converter(file, options = {})
+  snippet = IO.read(file, 2000)  # Read first 2000 characters
+  case snippet
+  when /STIL \d+\.\d+/
+    lambda do
+      STIL.add_pins(file)
+      # Use raw pin names in the output pattern and not the ALL pin group or similar, maybe
+      # make this an option in future though
+      dut.pin_pattern_order(*dut.pins.map { |id, pin| id })
+      STIL.execute(file, set_timesets: true)
+    end
+  else
+    Origen.log.error "Unknown input format for file: #{file}"
+    nil
+  end
+end
+
+ARGV.each do |input|
+  if c = converter(input)
+    name = Pathname.new(input).basename('.*').to_s
+
+    job = Origen::Generator::Job.new('anonymous', {})
+    Origen.app.current_jobs << job
+    if options[:output]
+      FileUtils.mkdir_p(options[:output]) unless File.exist?(options[:output])
+      job.instance_variable_set(:@output_pattern_directory, options[:output])
+    end
+
+    Origen.load_target
+
+    Origen::Generator::Pattern.convert(input) do
+      Pattern.create name: name do
+        c.call
+      end
+    end
+  end
+end

data/lib/origen_testers.rb

@@ -5,6 +5,7 @@ require 'active_support/concern'
 require 'require_all'
 require 'atp'
 require 'pathname'
+require 'origen_testers/origen_ext/generator/pattern'
 require 'origen_testers/origen_ext/generator/flow'
 require 'origen_testers/origen_ext/generator/resources'
 require 'origen_testers/origen_ext/application/runner'
@@ -41,6 +42,7 @@ end
 
 require 'origen_testers/igxl_based_tester'
 require 'origen_testers/smartest_based_tester'
+require 'origen_testers/stil_based_tester'
 require 'origen_testers/labview_based_tester'
 require 'origen_testers/pattern_compilers'
 require 'origen_testers/pattern_compilers/runner'

data/lib/origen_testers/api.rb

@@ -76,11 +76,6 @@ module OrigenTesters
       !is_vector_based?
     end
 
-    def stil?
-      defined?(OrigenTesters::StilBasedTester::Base) &&
-        is_a?(OrigenTesters::StilBasedTester::Base)
-    end
-
     def j750?
       is_a?(OrigenTesters::IGXLBasedTester::J750)
     end
@@ -98,6 +93,14 @@ module OrigenTesters
     end
     alias_method :uflex?, :ultraflex?
 
+    def stil?
+      is_a?(OrigenTesters::StilBasedTester::Base)
+    end
+
+    def d10?
+      is_a?(OrigenTesters::StilBasedTester::D10)
+    end
+
     def link?
       !!(self.class.to_s =~ /^OrigenLink::/)
     end
@@ -140,6 +143,7 @@ module OrigenTesters
     #       cc "step comment"
     #   end
     def c1(msg, options = {})
+      PatSeq.add_thread(msg) unless options[:no_thread_id]
       prefix = comment_char + ' '
       prefix += step_comment_prefix + ' ' if @step_comment_on
       if Origen.tester.generating == :program
@@ -171,7 +175,7 @@ module OrigenTesters
     def ss(msg = nil)
       div = step_comment_prefix.length
       div = 1 if div == 0
-      c1(step_comment_prefix * (70 / div))
+      c1(step_comment_prefix * (70 / div), no_thread_id: true)
       @step_comment_on = true
       if block_given?
         yield
@@ -182,9 +186,9 @@ module OrigenTesters
       if $_testers_enable_vector_comments
         timestamp = " #{execution_time_in_ns}ns #{step_comment_prefix}"
         str = step_comment_prefix * (70 / div)
-        c1 str.sub(/#{step_comment_prefix}{#{timestamp.length - 1}}$/, timestamp)
+        c1(str.sub(/#{step_comment_prefix}{#{timestamp.length - 1}}$/, timestamp), no_thread_id: true)
       else
-        c1(step_comment_prefix * (70 / div))
+        c1(step_comment_prefix * (70 / div), no_thread_id: true)
       end
     end
 
@@ -223,29 +227,33 @@ module OrigenTesters
         repeat:    nil
       }.merge(options)
 
-      if any_clocks_running?
-        update_running_clocks
-        if options[:repeat]
-          slice_repeats(options).each do |slice|
-            options[:repeat] = slice[0]
-            delay(options.delete(:repeat), options) do |options|
-              push_vector(options)
+      if PatSeq.thread
+        PatSeq.thread.cycle(options)
+      else
+        if any_clocks_running?
+          update_running_clocks
+          if options[:repeat]
+            slice_repeats(options).each do |slice|
+              options[:repeat] = slice[0]
+              delay(options.delete(:repeat), options) do |options|
+                push_vector(options)
+              end
+              slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+              options[:pin_vals] = current_pin_vals
             end
-            slice[1].each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
-            options[:pin_vals] = current_pin_vals
+            pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
+          else
+            push_vector(options)
+            pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
           end
-          pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
         else
-          push_vector(options)
-          pins_need_toggling.each { |clock_pin_name| clocks_running[clock_pin_name].toggle_clock }
-        end
-      else
-        if options[:repeat]
-          delay(options.delete(:repeat), options) do |options|
+          if options[:repeat]
+            delay(options.delete(:repeat), options) do |options|
+              push_vector(options)
+            end
+          else
             push_vector(options)
           end
-        else
-          push_vector(options)
         end
       end
     end

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

@@ -31,6 +31,7 @@ module OrigenTesters
               lo = ins.lo
               hi = ins.hi
             end
+
             size = 1
             if lo.is_a?(Array)
               size = lo.size if lo.size > size
@@ -80,6 +81,44 @@ module OrigenTesters
               completed_lines << line
             end
           end
+          # finish off any limit lines from sub tests
+          unless @limit_lines.nil?
+            tl = completed_lines.last
+            tnum = tl.tnum
+            @limit_lines.each do |line|
+              line.parameter = tl.parameter
+              line.sbin = tl.sbin
+              line.bin = tl.bin
+              line.tnum = tnum += 1 if tnum.is_a?(Numeric) && !line.tnum
+              completed_lines << line
+            end
+            @limit_lines = nil
+          end
+        end
+
+        def on_sub_test(node)
+          # for now assuming sub tests will be limits
+          tname = node.find(:object).value
+          # for some reason new_line :use_limit does not provide hbin, sbin etc accessors, duplicating behavior in on_test above
+          line = open_lines.last.dup
+          line.type = :use_limit
+          line.opcode = 'Use-Limit'
+          line.tname = tname
+          line.tnum = nil
+          open_lines << line
+          process_all(node.children)
+          @limit_lines = [] if @limit_lines.nil?
+          @limit_lines << open_lines.pop
+        end
+
+        def on_limit(node)
+          value, rule, unit, selector = *node
+          case rule
+          when 'gte'
+            current_line.lolim = value
+          when 'lte'
+            current_line.hilim = value
+          end
         end
 
         # Returns the scale that should be best used to represent the given number, returns

data/lib/origen_testers/labview_based_tester/pxie6570.rb

@@ -6,6 +6,7 @@ module OrigenTesters
       attr_accessor :default_source_wave_name, :default_capture_wave_name
 
       def initialize
+        @name = 'pxie'
         @pat_extension = 'digipatsrc'
         @capture_history = {}
         @source_history = {}

data/lib/origen_testers/origen_ext/generator/pattern.rb

@@ -0,0 +1,137 @@
+# This responsibility should be with OrigenTesters, starting to override the methods here
+# within OrigenTesters over time and it will be removed from Origen in future once fully
+# transferred
+require 'origen/generator/pattern'
+module Origen
+  class Generator
+    class Pattern
+      # @api private
+      def self.convert(file)
+        @converting = file
+        yield
+        @converting = nil
+      end
+
+      # @api private
+      def self.converting
+        @converting
+      end
+
+      private
+
+      def converting
+        self.class.converting
+      end
+
+      def header
+        Origen.tester.pre_header if Origen.tester.doc?
+        inject_separator
+        if $desc
+          c2 'DESCRIPTION:'
+          $desc.split(/\n/).each { |line| cc line }
+          inject_separator
+        end
+        c2 'GENERATED:'
+        c2 "  Time:    #{Origen.launch_time}"
+        c2 "  By:      #{Origen.current_user.name}"
+        c2 "  Mode:    #{Origen.mode}"
+        if converting
+          c2 "  Source:  #{converting}"
+
+        else
+          l = "  Command: origen g #{job.requested_pattern} -t #{Origen.target.file.basename}"
+          if Origen.environment && Origen.environment.file
+            l += " -e #{Origen.environment.file.basename}"
+          end
+          c2(l)
+        end
+        inject_separator
+        c2 'ENVIRONMENT:'
+        unless converting
+          c2 '  Application'
+          if Origen.app.rc
+            if Origen.app.rc.git?
+              c2 "    Source:    #{Origen.config.rc_url}"
+            else
+              c2 "    Vault:     #{Origen.config.vault}"
+            end
+          end
+          c2 "    Version:   #{Origen.app.version}"
+          unless Origen.app.config.release_externally
+            c2 "    Workspace: #{Origen.root}"
+          end
+          if Origen.app.rc && Origen.app.rc.git?
+            begin
+              @branch ||= Origen.app.rc.current_branch
+              @commit ||= Origen.app.rc.current_commit
+              status = "#{@branch}(#{@commit})"
+              @pattern_local_mods = !Origen.app.rc.local_modifications.empty? unless @pattern_local_mods_fetched
+              @pattern_local_mods_fetched = true
+              status += ' (+local edits)' if @pattern_local_mods
+              c2 "    Branch:    #{status}"
+            rescue
+              # No problem, we did our best
+            end
+          end
+        end
+        c2 '  Origen'
+        c2 '    Source:    https://github.com/Origen-SDK/origen'
+        c2 "    Version:   #{Origen.version}"
+        unless Origen.app.plugins.empty?
+          c2 '  Plugins'
+          Origen.app.plugins.sort_by { |p| p.name.to_s }.each do |plugin|
+            c2 "    #{plugin.name}:".ljust(30) + plugin.version
+          end
+        end
+        inject_separator
+
+        unless Origen.app.plugins.empty?
+          # Plugins can use config.shared_pattern_header to inject plugin-specific comments into the patterns header
+          header_printed = false
+          Origen.app.plugins.sort_by { |p| p.name.to_s }.each do |plugin|
+            unless plugin.config.shared_pattern_header.nil?
+              unless header_printed
+                c2 'Header Comments From Shared Plugins:'
+                header_printed = true
+              end
+              inject_pattern_header(
+                config_loc:      plugin,
+                scope:           :shared_pattern_header,
+                message:         "Header Comments From Shared Plugin: #{plugin.name}:",
+                message_spacing: 2,
+                line_spacing:    4,
+                no_separator:    true
+              )
+            end
+          end
+          inject_separator if header_printed
+        end
+
+        if Origen.app.plugins.current && !Origen.app.plugins.current.config.send(:current_plugin_pattern_header).nil?
+          # The top level plugin (if one is set) can further inject plugin-specific comment into the header.
+          # These will only appear if the plugin is the top-level plugin though.
+          inject_pattern_header(
+            config_loc: Origen.app.plugins.current,
+            scope:      :current_plugin_pattern_header,
+            message:    "Header Comments From The Current Plugin: #{Origen.app.plugins.current.name}:"
+          )
+        end
+
+        unless Origen.app.config.send(:application_pattern_header).nil?
+          inject_pattern_header(
+            config_loc: Origen.app,
+            scope:      :application_pattern_header,
+            message:    "Header Comments From Application: #{Origen.app.name}:"
+          )
+        end
+
+        if Origen.config.pattern_header
+          Origen.log.deprecated 'Origen.config.pattern_header is deprecated.'
+          Origen.log.deprecated 'Please use config.shared_pattern_header, config.application_pattern_header, or config.current_plugin_pattern_header instead.'
+          inject_separator
+        end
+        Origen.tester.close_text_block if Origen.tester.doc?
+      end
+    end
+  end
+end

data/lib/origen_testers/stil_based_tester.rb

@@ -0,0 +1,10 @@
+module OrigenTesters
+  module StilBasedTester
+    autoload :Base,                'origen_testers/stil_based_tester/base.rb'
+    autoload :D10,                 'origen_testers/stil_based_tester/d10.rb'
+    autoload :STIL,                'origen_testers/stil_based_tester/stil.rb'
+  end
+  # Convenience/Legacy names without the IGXLBasedTester namespace
+  autoload :D10,                   'origen_testers/stil_based_tester/d10.rb'
+  autoload :STIL,                  'origen_testers/stil_based_tester/stil.rb'
+end

data/lib/origen_testers/stil_based_tester/base.rb

@@ -0,0 +1,377 @@
+module OrigenTesters
+  module StilBasedTester
+    class Base
+      include VectorBasedTester
+
+      # When set to true generated patterns will only contain Pattern blocks, i.e. only vectors
+      attr_accessor :pattern_only
+
+      # 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:
+      #   $tester = J750.new
+      def initialize(options = {})
+        self.pattern_only = options.delete(:pattern_only)
+        @max_repeat_loop = 65_535
+        @min_repeat_loop = 2
+        @pat_extension = 'stil'
+        @compress = true
+
+        # @support_repeat_previous = true
+        @match_entries = 10
+        @name = 'stil'
+        @comment_char = '//'
+        @level_period = true
+        @inline_comments = true
+        @header_done = false
+        @footer_done = false
+      end
+
+      def stil_based?
+        true
+      end
+
+      # An internal method called by Origen to create the pattern header
+      def pattern_header(options = {})
+        options = {
+        }.merge(options)
+
+        @pattern_name = options[:pattern]
+
+        unless pattern_only
+          microcode 'STIL 1.0;'
+
+          microcode ''
+          microcode 'Signals {'
+          ordered_pins.each do |pin|
+            line = ''
+            line << "#{pin.name} "
+            if pin.direction == :input
+              line << 'In;'
+            elsif pin.direction == :output
+              line << 'Out;'
+            else
+              line << 'InOut;'
+            end
+            microcode "  #{line}"
+          end
+          microcode '}'
+
+          microcode ''
+          microcode 'SignalGroups {'
+          line = "\"#{ordered_pins_name || 'ALL'}\" = '"
+          ordered_pins.each_with_index do |pin, i|
+            unless i == 0
+              line << '+'
+            end
+            line << pin.name.to_s
+          end
+          microcode "  #{line}';"
+          microcode '}'
+
+          microcode ''
+          microcode "Timing t_#{@pattern_name} {"
+          (@wavesets || []).each_with_index do |w, i|
+            microcode '' if i != 0
+            microcode "  WaveformTable Waveset#{i + 1} {"
+            microcode "    Period '#{w[:period]}ns';"
+            microcode '    Waveforms {'
+            w[:lines].each do |line|
+              microcode "      #{line}"
+            end
+            microcode '    }'
+            microcode '  }'
+          end
+          microcode '}'
+
+          microcode ''
+          microcode "PatternBurst b_#{@pattern_name} {"
+          microcode "  PatList { #{@pattern_name}; }"
+          microcode '}'
+
+          microcode ''
+          microcode "PatternExec e_#{@pattern_name} {"
+          microcode "  Timing t_#{@pattern_name};"
+          microcode "  PatternBurst b_#{@pattern_name};"
+          microcode '}'
+          microcode ''
+        end
+
+        microcode "Pattern \"#{@pattern_name}\" {"
+        microcode "#{@pattern_name}:"
+        @header_done = true
+
+        if tester.ordered_pins_name.nil? && pattern_only
+          Origen.log.warn "WARN: SigName must be defined for STIL format.  Use pin_pattern_order(*pins, name: <sigName>).  Defaulting to use 'ALL'"
+        end
+      end
+
+      def set_timeset(timeset, period_in_ns = nil)
+        super
+        if pattern_only
+          # Why does D10 not include this?
+          # microcode "W #{timeset};"
+        else
+          @wavesets ||= []
+          wave_number = nil
+          @wavesets.each_with_index do |w, i|
+            if w[:name] == @timeset.name && w[:period] = @timeset.period_in_ns
+              wave_number = i
+            end
+          end
+          unless wave_number
+            lines = []
+            ordered_pins.each do |pin|
+              if pin.direction == :input || pin.direction == :io
+                line = "#{pin.name} { 01 { "
+                wave = pin.drive_wave
+                (wave ? wave.evaluated_events : []).each do |t, v|
+                  line << "'#{t}ns' "
+                  if v == 0
+                    line << 'D'
+                  elsif v == 0
+                    line << 'U'
+                  else
+                    line << 'D/U'
+                  end
+                  line << '; '
+                end
+                line << '}}'
+                lines << line
+              end
+              if pin.direction == :output || pin.direction == :io
+                line = "#{pin.name} { LHX { "
+                wave = pin.compare_wave
+                (wave ? wave.evaluated_events : []).each_with_index do |tv, i|
+                  t, v = *tv
+                  if i == 0 && t != 0
+                    line << "'0ns' X; "
+                  end
+                  line << "'#{t}ns' "
+                  if v == 0
+                    line << 'L'
+                  elsif v == 0
+                    line << 'H'
+                  else
+                    line << 'L/H/X'
+                  end
+                  line << '; '
+                end
+                line << '}}'
+                lines << line
+              end
+            end
+            @wavesets << { name: @timeset.name, period: @timeset.period_in_ns, lines: lines }
+            wave_number = @wavesets.size
+          end
+          microcode "W Waveset#{wave_number};"
+        end
+      end
+
+      # Capture the pin data from a vector to the tester.
+      #
+      # This method uses the Digital Capture feature (Selective mode) of the V93000 to capture
+      # the data from the given pins on the previous vector.
+      # Note that is does not actually generate a new vector.
+      #
+      # Note also that any drive cycles on the target pins can also be captured, to avoid this
+      # the wavetable should be set up like this to infer a 'D' (Don't Capture) on vectors where
+      # the target pin is being used to drive data:
+      #
+      #   PINS nvm_fail
+      #   0  d1:0  r1:D  0
+      #   1  d1:1  r1:D  1
+      #   2  r1:C  Capt
+      #   3  r1:D  NoCapt
+      #
+      # Sometimes when generating vectors within a loop you may want to apply a capture
+      # retrospectively to a previous vector, passing in an offset option will allow you
+      # to do this.
+      #
+      # ==== Examples
+      #   $tester.cycle                     # This is the vector you want to capture
+      #   $tester.store :pin => pin(:fail)  # This applys the required opcode to the given pins
+      #
+      #   $tester.cycle                     # This one gets captured
+      #   $tester.cycle
+      #   $tester.cycle
+      #   $tester.store(:pin => pin(:fail), :offset => -2) # Just realized I need to capture that earlier vector
+      #
+      #   # Capturing multiple pins:
+      #   $tester.cycle
+      #   $tester.store :pins => [pin(:fail), pin(:done)]
+      #
+      # Since the STIL store operates on a pin level (rather than vector level as on the J750)
+      # equivalent functionality can also be achieved by setting the store attribute of the pin
+      # itself prior to calling $tester.cycle.
+      # However it is recommended to use the tester API to do the store if cross-compatibility with
+      # other platforms, such as the J750, is required.
+      def store(*pins)
+        options = pins.last.is_a?(Hash) ? pins.pop : {}
+        options = { offset: 0
+                  }.merge(options)
+        pins = pins.flatten.compact
+        if pins.empty?
+          fail 'For the STIL generation you must supply the pins to store/capture'
+        end
+        pins.each do |pin|
+          pin.restore_state do
+            pin.capture
+            update_vector_pin_val pin, offset: options[:offset]
+            last_vector(options[:offset]).dont_compress = true
+            last_vector(options[:offset]).contains_capture = true
+          end
+        end
+      end
+      alias_method :capture, :store
+
+      # Same as the store method, except that the capture will be applied to the next
+      # vector to be generated.
+      #
+      # @example
+      #   $tester.store_next_cycle
+      #   $tester.cycle                # This is the vector that will be captured
+      def store_next_cycle(*pins)
+        options = pins.last.is_a?(Hash) ? pins.pop : {}
+        options = {
+        }.merge(options)
+        pins = pins.flatten.compact
+        if pins.empty?
+          fail 'For STIL generation you must supply the pins to store/capture'
+        end
+        pins.each { |pin| pin.save; pin.capture }
+        # Register this clean up function to be run after the next vector
+        # is generated, cool or what!
+        preset_next_vector do |vector|
+          vector.contains_capture = true
+          pins.each(&:restore)
+        end
+      end
+      alias_method :store!, :store_next_cycle
+
+      def match(pin, state, timeout_in_cycles, options = {})
+        Origen.log.warning "Call to match loop on pin #{pin.id} is not supported by the STIL generator and has been ignored"
+      end
+
+      # Add a loop to the pattern.
+      #
+      # Pass in the number of times to execute it, all vectors
+      # generated by the given block will be captured in the loop.
+      #
+      # ==== Examples
+      #   $tester.loop_vectors 3 do   # Do this 3 times...
+      #       $tester.cycle
+      #       some_other_method_to_generate_vectors
+      #   end
+      #
+      # For compatibility with the J750 you can supply a name as the first argument
+      # and that will simply be ignored when generated for the V93K tester...
+      #
+      #   $tester.loop_vectors "my_loop", 3 do   # Do this 3 times...
+      #       $tester.cycle
+      #       some_other_method_to_generate_vectors
+      #   end
+      def loop_vectors(name = nil, number_of_loops = 1, _global = false)
+        # The name argument is present to maych J750 API, sort out the
+        unless name.is_a?(String) || name.is_a?(Symbol)
+          name, number_of_loops, global = 'loop', name, number_of_loops
+        end
+        if number_of_loops > 1
+          @loop_counters ||= {}
+          if @loop_counters[name]
+            @loop_counters[name] += 1
+          else
+            @loop_counters[name] = 0
+          end
+          loop_name = @loop_counters[name] == 0 ? name : "#{name}_#{@loop_counters[name]}"
+          loop_name = loop_name.symbolize
+          microcode "#{loop_name}: Loop #{number_of_loops} {"
+          yield
+          microcode '}'
+        else
+          yield
+        end
+      end
+      alias_method :loop_vector, :loop_vectors
+
+      # An internal method called by Origen to generate the pattern footer
+      def pattern_footer(options = {})
+        cycle dont_compress: true     # one extra single vector before stop microcode
+        microcode 'Stop;' unless options[:subroutine]
+        microcode '}'
+        @footer_done = true
+      end
+
+      # Returns an array of subroutines called while generating the current pattern
+      def called_subroutines
+        @called_subroutines ||= []
+      end
+
+      # Call a subroutine.
+      #
+      # This calls a subroutine immediately following previous vector, it does not
+      # generate a new vector.
+      #
+      # Subroutines should always be called through this method as it ensures a running
+      # log of called subroutines is maintained and which then gets output in the pattern
+      # header to import the right dependencies.
+      #
+      # An offset option is available to make the call on earlier vectors.
+      #
+      # Repeated calls to the same subroutine will automatically be compressed unless
+      # option :suppress_repeated_calls is supplied and set to false. This means that for
+      # the common use case of calling a subroutine to implement an overlay the subroutine
+      # can be called for every bit that has the overlay and the pattern will automatically
+      # generate correctly.
+      #
+      # ==== Examples
+      #   $tester.call_subroutine("mysub")
+      #   $tester.call_subroutine("my_other_sub", :offset => -1)
+      def call_subroutine(name, options = {})
+        options = {
+          offset:                  0,
+          suppress_repeated_calls: true
+        }.merge(options)
+        called_subroutines << name.to_s.chomp unless called_subroutines.include?(name.to_s.chomp) || @inhibit_vectors
+
+        code = "Call #{name};"
+        if !options[:suppress_repeated_calls] ||
+           last_object != code
+          microcode code, offset: (options[:offset] * -1)
+        end
+      end
+
+      def push_comment(msg)
+        if @footer_done
+          stage.store msg unless @inhibit_comments
+        else
+          stage.store "Ann {*#{msg}*}" unless @inhibit_comments
+        end
+      end
+
+      # This is an internal method use by Origen which returns a fully formatted vector
+      # You can override this if you wish to change the output formatting at vector level
+      def format_vector(vec)
+        timeset = vec.timeset ? "#{vec.timeset.name}" : ''
+        pin_vals = vec.pin_vals ? "#{vec.pin_vals};".gsub(' ', '') : ''
+        sig_name = tester.ordered_pins_name || 'ALL'
+        if sig_name.nil?
+          Origen.log.warn "WARN: SigName must be defined for STIL format.  Use pin_pattern_order(*pins, name: <sigName>).  Default to 'ALL'"
+          sig_name = 'ALL'
+        end
+        if vec.repeat > 1
+          microcode = "Loop #{vec.repeat} {\n"
+        else
+          microcode = vec.microcode ? vec.microcode : ''
+        end
+        if vec.pin_vals && ($_testers_enable_vector_comments || vector_comments)
+          comment = "// V:#{vec.number} C:#{vec.cycle} #{vec.inline_comment}"
+        else
+          comment = vec.inline_comment.empty? ? '' : "Ann {*// #{vec.inline_comment}*}"
+        end
+
+        microcode_post = vec.repeat > 1 ? "\n}" : ''
+        "#{microcode}  V { \"#{sig_name}\" = #{pin_vals} }#{comment}#{microcode_post}"
+      end
+    end
+  end
+end

data/lib/origen_testers/stil_based_tester/d10.rb

@@ -0,0 +1,18 @@
+module OrigenTesters
+  module StilBasedTester
+    class D10 < Base
+      def initialize(options = {})
+        options = {
+          pattern_only: true
+        }.merge(options)
+        super(options)
+        @name = 'd10'
+      end
+
+      def d10?
+        true
+      end
+    end
+  end
+  D10 = StilBasedTester::D10
+end

data/lib/origen_testers/stil_based_tester/stil.rb

@@ -0,0 +1,8 @@
+module OrigenTesters
+  module StilBasedTester
+    class STIL < Base
+    end
+  end
+  # Support OrigenTesters::STIL.new
+  STIL = StilBasedTester::STIL
+end

data/lib/origen_testers/test/dut.rb

@@ -58,6 +58,8 @@ module OrigenTesters
           @digcap_settings = { digcap_format: :twos_complement }
         end
         @blocks = [Block.new(0, self), Block.new(1, self), Block.new(2, self)]
+
+        add_timeset 'tp0'
       end
 
       def on_create

data/lib/origen_testers/timing.rb

@@ -196,6 +196,10 @@ module OrigenTesters
         end
         @_last_timeset_change = change
       end
+      if dut.timesets[timeset.name]
+        dut.timeset = timeset.name
+        dut.current_timeset_period = timeset.period_in_ns
+      end
     end
 
     def before_timeset_change(options = {})

data/lib/origen_testers/vector_generator.rb

@@ -389,6 +389,16 @@ module OrigenTesters
       @ordered_pins_cache ||= ordered_pins(options)
     end
 
+    # Retrieve optional 'name' meta passed in with the pin_pattern_order call
+    def ordered_pins_name
+      pinorder = Origen.app.pin_pattern_order.dup
+      if Origen.app.pin_pattern_order.last.is_a?(Hash)
+        options = pinorder.pop
+        name = options[:name]
+      end
+      name
+    end
+
     def ordered_pins(options = {})
       options = {
         include_inhibited_pins: false,

data/pattern/freq_counter.rb

@@ -1,5 +1,5 @@
 # Pattern to exercise the Freq Counter feature
-unless $tester.v93k? || $tester.pxie6570?
+unless $tester.v93k? || $tester.pxie6570? || $tester.stil?
   Pattern.create do
     $dut.freq_count
   end

data/pattern/mem_test.rb

@@ -1,4 +1,4 @@
-unless $tester.v93k? || $tester.pxie6570?
+unless $tester.v93k? || $tester.pxie6570? || $tester.stil?
   # Pattern to exercise the memory test feature of tester
   Pattern.create(:memory_test => true) do
     

data/program/basic_interface.rb

@@ -2,4 +2,13 @@ Flow.create interface: 'OrigenTesters::Test::BasicInterface' do
 
   functional :test1, sbin: 100, number: 20000
 
+  # test multi limit support if uflex, not sure what platforms support this or the syntax
+  if tester.uflex?
+    functional :test2, sbin: 101, number: 20020,
+      sub_tests: [
+        sub_test(:lim1, lo: -2, hi: 2),
+        sub_test(:lim2, lo: -1, hi: 1)
+      ]
+  end
+
 end

data/program/prb1.rb

@@ -4,7 +4,9 @@
 # similar to Pattern.create.
 Flow.create interface: 'OrigenTesters::Test::Interface', flow_description: 'Probe1 Main' do
 
-  self.resources_filename = 'prb1'
+  unless Origen.app.environment.name == 'v93k_global'
+    self.resources_filename = 'prb1'
+  end
 
   import 'components/prb1_main'
 

data/program/prb2.rb

@@ -5,7 +5,9 @@ Flow.create interface: 'OrigenTesters::Test::Interface' do
   # Test that this can be overridden from the target at flow-level
   self.add_flow_enable = :enabled
 
-  self.resources_filename = 'prb2'
+  unless Origen.app.environment.name == 'v93k_global'
+    self.resources_filename = 'prb2'
+  end
 
   func :erase_all, duration: :dynamic, number: 10000
 

data/templates/origen_guides/pattern/stil.md.erb

@@ -0,0 +1,35 @@
+% render "layouts/guides.html" do
+
+#### STIL
+
+Patterns can be generated into STIL cyclized vector format by creating an environment like this:
+
+~~~ruby
+# environment/stil.rb
+OrigenTesters::STIL.new
+~~~
+
+All of the
+[Common Pattern API](<%= path "guides/pattern/common" %>) should be supported in addition to
+[custom waveform codes](<%= path "guides/pattern/v93k" %>) like the V93K.
+
+If the timeset waveforms used by the pattern are
+[fully defined within your Origen application](<%= path "guides/pattern/timing/#Defining_Timesets" %>)
+then that information will also be represented within the generated STIL pattern.
+
+A pattern containing a `Pattern { }` block only - i.e. only vectors and without the `Signals { }`, 
+`Timing { }` and other frontmatter blocks - can be generated by setting up your environment as follows:
+
+~~~ruby
+OrigenTesters::STIL.new pattern_only: true
+~~~
+
+An alias for this configuration is the `D10` tester environment setup:
+
+~~~ruby
+# environment/d10.rb
+OrigenTesters::D10.new
+~~~
+
+
+% end

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

@@ -136,6 +136,59 @@ information):
 * other
 * empty
 
+#### Custom Test Instance Types
+
+The <code>add_til</code> method is available to describe a custom instance. An example is below.
+
+~~~ruby
+# app_interface
+
+def initialize(options = {})
+  add_til :my_lib,
+    test_a: {
+      # Basic arg
+      input1: :arg0,
+      # Arg with default value
+      input2: [:arg1, 'default'],
+      # Arg with default and list of predefined allowed values
+      input3: [:arg2, 'volt', %w(volt curr)],
+      # Attribute aliases can be defined like this:
+      aliases: {
+        some_alias_name: :input1,
+	another_alias:   :input2
+      },
+      # Define any methods you want for the instance like this
+      methods: {
+        # An optional finalize method can be supplied, this method will be called
+	# immediately before the test instance is rendered. The test object itself
+	# will be passed as an argument.
+	finalize: lambda do |ti|
+	  ti.proc_name = 'blah_blah'
+	  ti.proc_called_as = ''
+	end,
+	set_some_arg: lambda do |ti, val|
+	  ti.input1 = val
+	end
+      }
+    },
+    
+    test_b: {
+      # ...
+    }
+end
+
+# Here's how to use the custom library
+def do_test_a(name, options = {})
+  ti = test_instances.my_lib.test_a name
+  ti.input1 = 50.0
+  ti.input3 = 'curr'
+  
+  # ...
+end
+~~~
+
+#### Legacy Custom Test Instance Types (prefered method is above)
+
 If you need a different type you can still call the add method, the difference in the
 returned instance for an unrecognized type is:
 

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

@@ -1,5 +1,38 @@
 % render "layouts/guides.html" do
 
-<%= render "partials/placeholder.md" %>
+Be sure to read and understand the guide to
+[Creating an Interface](<%= path "guides/program/interface" %>) 
+and 
+[J750 API](<%= path "guides/program/j750" %>)
+before reading this section.
+This guide will describe the API differences between UFlex/IG-XL and J750/IG-XL test program 
+generation.
+
+### Creating a flow entry with multiple Use-Limit lines
+
+~~~ruby
+  functional :test2, sbin: 101, number: 20020,
+    sub_tests: [
+      sub_test(:limit_name1, lo: -2, hi: 2),
+      sub_test(:limit_name2, lo: -1, hi: 1)
+    ]
+~~~
+
+~~~ruby  
+  # Another example using a custom instance
+  def sar_cal_test(name, options = {})
+    ti = test_instances.sar_tests.sar_cal name
+    # ...
+    
+    # Assign fixed limits
+    options[:sub_tests] = [
+      sub_test(:source_gain, lo: 0.99, hi: 1.01),
+      sub_test(:source_offset, lo: -0.001, hi: 0.001)
+    ]
+    
+    # add the test to the flow
+    flow.test ti, options
+  end
+~~~
 
 % end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_testers
 version: !ruby/object:Gem::Version
-  version: 0.20.0
+  version: 0.21.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-06 00:00:00.000000000 Z
+date: 2019-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 0.44.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 0.44.0
 - !ruby/object:Gem::Dependency
   name: require_all
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +58,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.1.3
+- !ruby/object:Gem::Dependency
+  name: origen_stil
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.1
 description: 
 email:
 - stephen.f.mcginty@gmail.com
@@ -68,10 +82,12 @@ files:
 - config/application.rb
 - config/boot.rb
 - config/commands.rb
+- config/global_commands.rb
 - config/shared_commands.rb
 - config/users.rb
 - config/version.rb
 - lib/commands/build.rb
+- lib/commands/convert.rb
 - lib/commands/run.rb
 - lib/origen_testers.rb
 - lib/origen_testers/api.rb
@@ -230,6 +246,7 @@ files:
 - lib/origen_testers/origen_ext/application/runner.rb
 - lib/origen_testers/origen_ext/generator.rb
 - lib/origen_testers/origen_ext/generator/flow.rb
+- lib/origen_testers/origen_ext/generator/pattern.rb
 - lib/origen_testers/origen_ext/generator/resources.rb
 - lib/origen_testers/origen_ext/pins/pin.rb
 - lib/origen_testers/origen_ext/pins/pin_collection.rb
@@ -287,6 +304,10 @@ files:
 - lib/origen_testers/smartest_based_tester/v93k/test_suite.rb
 - lib/origen_testers/smartest_based_tester/v93k/test_suites.rb
 - lib/origen_testers/smartest_based_tester/v93k/variables_file.rb
+- lib/origen_testers/stil_based_tester.rb
+- lib/origen_testers/stil_based_tester/base.rb
+- lib/origen_testers/stil_based_tester/d10.rb
+- lib/origen_testers/stil_based_tester/stil.rb
 - lib/origen_testers/test/basic_interface.rb
 - lib/origen_testers/test/block.rb
 - lib/origen_testers/test/custom_test_interface.rb
@@ -351,6 +372,7 @@ files:
 - templates/origen_guides/pattern/pins.md.erb
 - templates/origen_guides/pattern/registers.md.erb
 - templates/origen_guides/pattern/running.md.erb
+- templates/origen_guides/pattern/stil.md.erb
 - templates/origen_guides/pattern/timing.md.erb
 - templates/origen_guides/pattern/ultraflex.md.erb
 - templates/origen_guides/pattern/v93k.md.erb