origen_testers 0.51.4 → 0.52.0

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

@@ -7,11 +7,19 @@ module OrigenTesters
           %w(
             name
             comment
+            bypass
 
             test_method
 
             pattern
             specification
+            seq
+            burst
+
+            spec_namespace
+            spec_path
+            seq_namespace
+            seq_path
           )
 
         ALIASES = {
@@ -22,6 +30,7 @@ module OrigenTesters
         DEFAULTS = {
         }
 
+        NO_STRING_TYPES = [:list_strings, :list_classes, :class]
         # Generate accessors for all attributes and their aliases
         ATTRS.each do |attr|
           if attr == 'name' || attr == 'pattern'
@@ -42,24 +51,122 @@ module OrigenTesters
         end
 
         def lines
+          # Initialize path setting
+          # prefix = test method library prefix expectations
+          # self.spec_namespace = instance override from the tester specification namespace
+          # self.seq_namespace = instance override from the tester sequence namespace
+          # self.spec_path = instance override from the tester specification path
+          # self.seq_path = instance override from the tester sequence path
+          if Origen.interface.respond_to? :custom_smt8_prefix
+            prefix = Origen.interface.custom_smt8_prefix
+          else
+            prefix = 'measurement.'
+          end
+          spec_namespace = self.spec_namespace || tester.package_namespace
+          spec_path      = self.spec_path || tester.spec_path
+          seq_namespace  = self.seq_namespace || tester.package_namespace
+          seq_path       = self.seq_path || tester.seq_path
           l = []
-          l << "suite #{name} calls #{test_method.klass} {"
+          l << "suite #{name} calls #{test_method.klass[0].downcase + test_method.klass[1..-1]} {"
           if pattern && !pattern.to_s.empty?
-            l << "    measurement.pattern = setupRef(#{tester.package_namespace}.patterns.#{pattern});"
+            l << "    #{prefix}pattern = setupRef(#{seq_namespace}.patterns.#{pattern});"
+          end
+          if seq && !seq.to_s.empty?
+            l << "    #{prefix}operatingSequence = setupRef(#{seq_namespace}.#{seq_path}.#{seq});"
+          end
+          if burst && !burst.to_s.empty?
+            l << "    #{prefix}operatingSequence = setupRef(#{seq_namespace}.#{seq_path}.#{burst});"
           end
           if specification && !specification.to_s.empty?
-            l << "    measurement.specification = setupRef(#{tester.package_namespace}.specs.#{specification});"
+            l << "    #{prefix}specification = setupRef(#{spec_namespace}.#{spec_path}.#{specification});"
+          end
+          if bypass
+            l << '    bypass = true;'
           end
           test_method.sorted_parameters.each do |param|
             name = param[0]
             unless name.is_a?(String)
               name = name.to_s[0] == '_' ? name.to_s.camelize(:upper) : name.to_s.camelize(:lower)
             end
-            l << "    #{name} = #{wrap_if_string(test_method.format(param[0]))};"
+            if [true, false].include? test_method.format(param[0])
+              l << "    #{name} = #{wrap_if_string(test_method.format(param[0]))};"
+            elsif NO_STRING_TYPES.include?(param.last) && test_method.format(param[0]).is_a?(String) && !test_method.format(param[0]).empty?
+              l << "    #{name} = #{test_method.format(param[0])};"
+            elsif test_method.format(param[0]).is_a?(String) && !test_method.format(param[0]).empty?
+              l << "    #{name} = #{wrap_if_string(test_method.format(param[0]))};"
+            elsif param.last.is_a? Hash
+              if !test_method.format(name).nil? && !test_method.format(name).is_a?(Hash)
+                fail "#{name} parameter structure requires a Hash but value provided is #{test_method.format(name).class}"
+              elsif test_method.format(name).nil? && tester.print_all_params
+                l = add_nested_params(l, name, 'param0', {}, param.last, 1)
+              elsif test_method.format(name).nil?
+                # Do nothing
+              else
+                test_method.format(name).each do |key, meta_hash|
+                  l = add_nested_params(l, name, key, meta_hash, param.last, 1)
+                end
+              end
+            end
           end
           l << '}'
           l
         end
+
+        # rubocop:disable Metrics/ParameterLists: Avoid parameter lists longer than 5 parameters.
+        def add_nested_params(l, name, key, value_hash, nested_params, nested_loop_count)
+          nested_params_accepted_keys = []
+          skip_keys                   = []
+          unless value_hash.nil?
+            unless value_hash.is_a?(Hash)
+              fail "Provided value to nested params was not a Hash. Instead the value was #{value_hash.class}"
+            end
+            dynamic_spacing = ' ' * (4 * nested_loop_count)
+            l << "#{dynamic_spacing}#{name}[#{key}] = {" unless name.nil?
+            nested_params.each do |nested_param|
+              # Guarentee hash is using all symbol keys
+              # Since we cannot guarentee ruby version is greater than 2.5, we have to use an older syntax to
+              value_hash = value_hash.inject({}) { |memo, (k, v)| memo[k.to_sym] = v; memo }
+              nested_key = nested_param.first.to_sym
+              nested_key_underscore = nested_key.to_s.underscore.to_sym
+              nested_params_accepted_keys << nested_key
+              nested_params_accepted_keys << nested_key_underscore
+              # We cannot create nested member functions with aliases
+              # Requirement for hash parameter passing is to pass one of the key types and not both
+              if value_hash.keys.include?(nested_key) &&
+                 value_hash.keys.include?(nested_key_underscore) && nested_key != nested_key_underscore
+                fail 'You are using a hash based test method and provided both the parameter name and alias name.'
+              end
+              nested_key = nested_key_underscore if value_hash.keys.include?(nested_key_underscore)
+              if nested_param.last.first.is_a?(Hash) && value_hash[nested_key].is_a?(Hash)
+                value_hash[nested_key].each do |inner_key, inner_meta_hash|
+                  l = add_nested_params(l, nested_param.first, inner_key, value_hash.dig(nested_key, inner_key), nested_param.last.first, nested_loop_count + 1)
+                  skip_keys << nested_key
+                end
+              elsif nested_param.last.first.is_a?(Hash) && tester.print_all_params
+                l = add_nested_params(l, nested_param.first, 'param0', {}, nested_param.last.first, nested_loop_count + 1)
+              end
+              type = nested_param.last.first
+              if NO_STRING_TYPES.include?(nested_param.last.first) && value_hash[nested_key] && !skip_keys.include?(nested_key)
+                l << "    #{dynamic_spacing}#{nested_param.first} = #{test_method.handle_val_type(value_hash[nested_key], type, nested_param.first)};"
+              elsif value_hash[nested_key] && !skip_keys.include?(nested_key)
+                l << "    #{dynamic_spacing}#{nested_param.first} = #{wrap_if_string(test_method.handle_val_type(value_hash[nested_key], type, nested_param.first))};"
+              elsif NO_STRING_TYPES.include?(nested_param.last.first) && !nested_param.last.last.is_a?(Hash) && tester.print_all_params && !skip_keys.include?(nested_key)
+                l << "    #{dynamic_spacing}#{nested_param.first} = #{test_method.handle_val_type(nested_param.last.last, type, nested_param.first)};"
+              elsif !nested_param.last.last.is_a?(Hash) && tester.print_all_params && !skip_keys.include?(nested_key)
+                l << "    #{dynamic_spacing}#{nested_param.first} = #{wrap_if_string(test_method.handle_val_type(nested_param.last.last, type, nested_param.first))};"
+              end
+            end
+            l << "#{dynamic_spacing}};" unless name.nil?
+            # Sanity check there are not overpassed parameters
+            value_hash.keys.each do |nested_key|
+              unless nested_params_accepted_keys.include?(nested_key.to_sym)
+                fail "You provided a parameter \'#{nested_key}\' that was not an accepted parameter to the hash parameter \'#{name}\'"
+              end
+            end
+          end
+          l
+        end
+        # rubocop:enable Metrics/ParameterLists: Avoid parameter lists longer than 5 parameters.
       end
     end
   end

data/lib/origen_testers/stil_based_tester/base.rb

@@ -15,6 +15,7 @@ module OrigenTesters
         @min_repeat_loop = 2
         @pat_extension = 'stil'
         @compress = true
+        @use_timing_equations = options[:use_timing_equations]
 
         # @support_repeat_previous = true
         @match_entries = 10
@@ -93,12 +94,29 @@ module OrigenTesters
           output_group_definition(flattened_ordered_pins, "#{ordered_pins_name || 'ALL'}")
           microcode '}'
 
+          # output the period category specs
+          if @use_timing_equations
+            microcode ''
+            microcode 'Spec {'
+            microcode "  Category c_#{@pattern_name} {"
+            (@wavesets || []).each_with_index do |w, i|
+              microcode "    period_#{w[:name]} = '#{w[:period]}ns';"
+            end
+            microcode '  }'
+            microcode '}'
+          end
+
           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';"
+            period_var = "period_#{w[:name]}"
+            if @use_timing_equations
+              microcode "    Period '#{period_var}';"
+            else
+              microcode "    Period '#{w[:period]}ns';"
+            end
             microcode '    Waveforms {'
             w[:lines].each do |line|
               microcode "      #{line}"
@@ -115,6 +133,7 @@ module OrigenTesters
 
           microcode ''
           microcode "PatternExec e_#{@pattern_name} {"
+          microcode "  Category c_#{@pattern_name};" if @use_timing_equations
           microcode "  Timing t_#{@pattern_name};"
           microcode "  PatternBurst b_#{@pattern_name};"
           microcode '}'
@@ -131,6 +150,27 @@ module OrigenTesters
       end
 
       def set_timeset(t, period_in_ns = nil)
+        # check for period size override from the app if performing convert command
+        if Origen.current_command == 'convert'
+          listeners = Origen.listeners_for(:convert_command_set_period_in_ns)
+          if listeners.empty?
+            unless @call_back_message_displayed
+              Origen.log.warn 'STIL output is generated using "origen convert" with no timeset period callback method defined. Default period size will be used.'
+              Origen.log.info 'stil tester implements a callback for setting the timeset period size when converting a pattern to stil format'
+              Origen.log.info 'to use the callback feature add the following define to your app in config/application.rb'
+              Origen.log.info '  def convert_command_set_period_in_ns(timeset_name)'
+              Origen.log.info '    return 25 if timeset_name == "timeset0"'
+              Origen.log.info '    return 30 if timeset_name == "timeset1"'
+              Origen.log.info '    40'
+              Origen.log.info '  end'
+              @call_back_message_displayed = true
+            end
+          else
+            listeners.each do |listener|
+              period_in_ns = listener.convert_command_set_period_in_ns(t)
+            end
+          end
+        end
         super
         if pattern_only
           # Why does D10 not include this?
@@ -140,25 +180,32 @@ module OrigenTesters
           wave_number = nil
           @wavesets.each_with_index do |w, i|
             if w[:name] == timeset.name && w[:period] = timeset.period_in_ns
-              wave_number = i
+              wave_number = i + 1               # bug fix wave numbers are 1 more than their index #
             end
           end
           unless wave_number
             lines = []
+            period_var = "period_#{timeset.name}"
             flattened_ordered_pins.each do |pin|
               if pin.direction == :input || pin.direction == :io
                 line = "#{pin.name} { 01 { "
                 wave = pin.drive_wave if tester.timeset.dut_timeset
-                (wave ? wave.evaluated_events : []).each do |t, v|
-                  line << "'#{t}ns' "
-                  if v == 0
-                    line << 'D'
-                  elsif v == 1
-                    line << 'U'
-                  else
-                    line << 'D/U'
+                if wave
+                  (@use_timing_equations ? wave.events : wave.evaluated_events).each do |t, v|
+                    if @use_timing_equations
+                      line << "'#{t.to_s.gsub('period', period_var)}' "
+                    else
+                      line << "'#{t}ns' "
+                    end
+                    if v == 0
+                      line << 'D'
+                    elsif v == 1
+                      line << 'U'
+                    else
+                      line << 'D/U'
+                    end
+                    line << '; '
                   end
-                  line << '; '
                 end
                 line << '}}'
                 lines << line
@@ -166,20 +213,26 @@ module OrigenTesters
               if pin.direction == :output || pin.direction == :io
                 line = "#{pin.name} { LHX { "
                 wave = pin.compare_wave if tester.timeset.dut_timeset
-                (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'
+                if wave
+                  (@use_timing_equations ? wave.events : wave.evaluated_events).each_with_index do |tv, i|
+                    t, v = *tv
+                    if i == 0 && t != 0
+                      line << "'0ns' X; "
+                    end
+                    if @use_timing_equations
+                      line << "'#{t.to_s.gsub('period', period_var)}' "
+                    else
+                      line << "'#{t}ns' "
+                    end
+                    if v == 0
+                      line << 'L'
+                    elsif v == 0
+                      line << 'H'
+                    else
+                      line << 'L/H/X'
+                    end
+                    line << '; '
                   end
-                  line << '; '
                 end
                 line << '}}'
                 lines << line

data/lib/origen_testers/test/custom_test_interface.rb

@@ -33,11 +33,23 @@ module OrigenTesters
         end
       end
 
+      def custom_hash(name, options = {})
+        name = "custom_hash_#{name}".to_sym
+        if tester.v93k? && tester.smt8?
+          ti = test_methods.my_tml.test_hash
+          ti.my_arg_hash = {
+            my_param_name: {
+              my_arg2: 1
+            }
+          }
+        end
+      end
+
       private
 
       def add_custom_tml
         add_tml :my_tml,
-                test_a: {
+                test_a:    {
                   # Parameters can be defined with an underscored symbol as the name, this can be used
                   # if the C++ implementation follows the standard V93K convention of calling the attribute
                   # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
@@ -79,10 +91,32 @@ module OrigenTesters
                     end
                   }
                 },
-                test_b: {
+                test_b:    {
                   render_limits_in_tf: false,
                   my_arg0:             [:string, ''],
                   my_arg1:             [:string, 'b_default_value']
+                },
+                test_hash: {
+                  # Parameters can be defined with an underscored symbol as the name, this can be used
+                  # if the C++ implementation follows the standard V93K convention of calling the attribute
+                  # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
+                  # first example.
+                  # The attribute definition has two required parameters, the type and the default value.
+                  # The type can be :string, :current, :voltage, :time, :frequency, or :integer
+                  # An optional 3rd parameter can be supplied to give an array of allowed values. If supplied,
+                  # Origen will raise an error upon an attempt to set it to an unlisted value.
+                  tester_state:   [:string, 'CONNECTED', %w(CONNECTED UNCHANGED)],
+                  test_name:      [:string, 'Functional'],
+                  my_list_string: [:list_strings, %w(E1 E2)],
+                  my_list_class:  [:list_classes, %w(E1 E2)],
+                  my_arg_hash:    [{
+                    my_arg0: [:string, ''],
+                    my_arg1: [:string, 'a_default_value'],
+                    my_arg2: [:integer, 0],
+                    my_arg2: [:list_strings, %w(E1 E2)],
+                    my_arg3: [:list_classes, %w(E1 E2)]
+                  }]
+                  # Define any methods you want the test method to have
                 }
       end
 

data/lib/origen_testers/test/interface.rb

@@ -12,6 +12,67 @@ module OrigenTesters
       def initialize(options = {})
         @environment = options[:environment]
         add_charz
+        add_my_tml if tester.v93k?
+      end
+
+      def add_my_tml
+        add_tml :my_hash_tml,
+                class_name:   'MyTmlHashNamespace',
+
+                # Here is a test definition.
+                # The identifier should be lower-cased and underscored, in-keeping with Ruby naming conventions.
+                # By default the class name will be the camel-cased version of this identifier, so 'myTest' in
+                # this case.
+                my_hash_test: {
+                  # [OPTIONAL] The C++ test method class name can be overridden from the default like this:
+                  class_name:             'MyHashExampleClass',
+                  # [OPTIONAL] If the test method does not require a definition in the testmethodlimits section
+                  #    of the .tf file, you can suppress like this:
+                  # render_limits_in_file: false,
+                  # Parameters can be defined with an underscored symbol as the name, this can be used
+                  # if the C++ implementation follows the standard V93K convention of calling the attribute
+                  # the camel cased version, starting with a lower-cased letter, i.e. 'testerState' in this
+                  # first example.
+                  # The attribute definition has two required parameters, the type and the default value.
+                  # The type can be :string, :current, :voltage, :time, :frequency, integer, :double or :boolean
+                  pin_list:               [:string, ''],
+                  samples:                [:integer, 1],
+                  precharge_voltage:      [:voltage, 0],
+                  settling_time:          [:time, 0],
+                  # An optional parameter that sets the limits name in the 'testmethodlimits' section
+                  # of the generated .tf file.  Defaults to 'Functional' if not provided.
+                  test_name:              [:string, 'HashExample'],
+                  # An optional 3rd parameter can be supplied to provide an array of allowed values. If supplied,
+                  # Origen will raise an error upon an attempt to set it to an unlisted value.
+                  tester_state:           [:string, 'CONNECTED', %w(CONNECTED UNCHANGED DISCONNECTED)],
+                  force_mode:             [:string, 'VOLT', %w(VOLT CURR)],
+                  # The name of another parameter can be supplied as the type argument, meaning that the type
+                  # here will be either :current or :voltage depending on the value of :force_mode
+                  # force_value: [:force_mode, 3800.mV],
+                  # In cases where the C++ library has deviated from standard attribute naming conventions
+                  # (camel-cased with lower cased first character), the absolute attribute name can be given
+                  # as a string.
+                  # The Origen accessor for these will be the underscored version, with '.' characters
+                  # converted to underscores e.g. tm.an_unusual_name
+                  'hashParameter':        [{ param_name0: [:string, 'NO'], param_name1: [:integer, 0] }],
+                  'hashParameter2':       [{ param_name0: [:string, 'NO'], param_name1: [:integer, 0] }],
+                  'nestedHashParameter':  [{
+                    param_name0:        [:string, ''],
+                    param_list_strings: [:list_strings, %w(E1 E2)],
+                    param_list_classes: [:list_classes, %w(E1 E2)],
+                    param_name1:        [{
+                      param_name0:        [:integer, 0],
+                      param_list_strings: [:list_strings, %w(E1 E2)],
+                      param_list_classes: [:list_classes, %w(E1 E2)]
+                    }]
+                  }],
+                  'nestedHashParameter2': [{
+                    param_name0: [:string, ''],
+                    param_name1: [{
+                      param_name0: [:integer, 0]
+                    }]
+                  }]
+                }
       end
 
       def add_charz
@@ -218,6 +279,68 @@ module OrigenTesters
         end
       end
 
+      def my_hash_test(name, options = {})
+        number = options[:number]
+
+        if tester.v93k? && tester.smt8?
+          block_loop(name, options) do |block, i|
+            options[:number] = number + i if number && i
+            tm = test_methods.my_hash_tml.my_hash_test
+            tm.hashParameter = {
+              param1: {}
+            }
+            tm.nestedHashParameter = {
+              my_param_name0: {
+                param_name0: 'hello',
+                param_name1: {
+                  my_param_name1: {
+                    param_name0: 1
+                  },
+                  my_param_name2: {
+                    param_name0: 2
+                  },
+                  my_param_name3: {
+                    param_name0: 3
+                  }
+                }
+              }
+            }
+            tm.nestedHashParameter2 = {
+              my_param_name4: {
+                param_name0: 'goodbye'
+              },
+              my_param_name5: {
+                param_name0: 'goodbye forever'
+              }
+            }
+            ts = test_suites.run(name, options)
+            ts.test_method = tm
+            ts.spec = options.delete(:pin_levels) if options[:pin_levels]
+            ts.spec ||= 'specs.Nominal'
+            flow.test ts, options
+          end
+        end
+      end
+
+      def my_override_spec_test(name, options = {})
+        number = options[:number]
+
+        if tester.v93k? && tester.smt8?
+          tm = test_methods.ac_tml.ac_test.functional_test
+          ts = test_suites.run(name, options)
+          ts.test_method = tm
+          ts.spec = options.delete(:pin_levels) if options[:pin_levels]
+          ts.spec ||= 'specs.Nominal'
+          ts.pattern = 'pat1'
+          ts.burst = 'sequence1'
+          ts.spec_path = 'myCustomSpecPath'
+          ts.seq_path  = 'myCustomSeqPath'
+          ts.spec_namespace = 'myCustomSpecNamespace'
+          ts.seq_namespace  = 'myCustomSeqNamespace'
+          flow.test ts, options
+        end
+      end
+
       def block_loop(name, options)
         if options[:by_block]
           if tester.j750? || tester.uflex?

data/program/components/_prb1_main.rb

@@ -1,4 +1,10 @@
 Flow.create do |options|
+  if tester.smt8?
+    my_hash_test :hash_example, number: 8000
+    my_override_spec_test :spec_override_example, number: 8010
+    add_auxiliary_flow :POWERDOWN, path: 'testflow.POWERDOWN'
+  end
+
   # Instantiate tests via the
   # interface
   func 'program_ckbd', tname: 'PGM_CKBD', tnum: 1000, bin: 100, soft_bin: 1100
@@ -240,6 +246,9 @@ Flow.create do |options|
     log 'Passing test flags works as expected'
     func :test_with_no_flags, bypass: false, output_on_pass: false, output_on_fail: false, value_on_pass: false, value_on_fail: false, per_pin_on_pass: false, per_pin_on_fail: false, number: 6020
     func :test_with_flags, bypass: true, output_on_pass: true, output_on_fail: true, value_on_pass: true, value_on_fail: true, per_pin_on_pass: true, per_pin_on_fail: true, number: 6030
+  elsif tester.smt8?
+    func :test_with_no_flags, bypass: false, number: 6020
+    func :test_with_flags, bypass: true, number: 6030
   end
 
   if tester.smt7?

data/program/custom_tests.rb

@@ -9,5 +9,8 @@ Flow.create interface: 'OrigenTesters::Test::CustomTestInterface', flow_descript
 
   if tester.v93k?
     custom_b :test4, number: 30040
+    if tester.smt8?
+      custom_hash :test5, number: 30050
+    end
   end
 end

data/program/flow_control.rb

@@ -319,6 +319,18 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
     set_flag '$global'
   end
 
+  log 'Test unset_flag functionality'
+  set_flag '$my_unset_flag'
+  unset_flag '$my_unset_flag'
+
+  log 'Test add_flag functionality'
+  add_flag :my_uncalled_flag
+
+  log 'Test inout variables'
+  add_flag :MY_INOUT_ADD_FLAG
+  if_flag '$MY_INOUT_ADD_FLAG' do
+  end
+
   if tester.v93k?
     log "This should retain the set-run-flag in the else conditional"
     func :test22, id: :at22, number: 51480
@@ -349,7 +361,7 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
     func :test36, on_fail: { render: 'multi_bin;' }, if_flag: :my_flag, number: 51570
   end
 
-  if tester.v93k? && !tester.smt8?
+  if tester.v93k?
     log "Tests of flow loop"
     loop from: 0, to: 5, step: 1, var: '$LOOP_VARIABLE' do
       func :test_myloop, number: 56000
@@ -360,9 +372,11 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
       func :test_myloop2, number: 5610
     end
 
-    log "Tests of flow loop, non-default test number increment" 
-    loop from: 0, to: 5, var: '$LOOP_VARIABLE', test_num_inc: 2 do
-      func :test_myloop3, number: 56200
+    if tester.smt7?
+      log "Tests of flow loop, non-default test number increment" 
+      loop from: 0, to: 5, var: '$LOOP_VARIABLE', test_num_inc: 2 do
+        func :test_myloop3, number: 56200
+      end
     end
  
     log "Tests of decrementing loop"
@@ -371,14 +385,29 @@ Flow.create interface: 'OrigenTesters::Test::Interface', flow_name: "Flow Contro
     end
  
     log "Tests of nested flow loop, depth 3"
-    loop from: 0, to: 9, step: 2, var: '$LOOP_VARIABLE1'do
-      loop from: 1, to: 10, step: 1, var: '$LOOP_VARIABLE2' do
-        loop from: 1, to: 5, step: 1, var: '$LOOP_VARIABLE3' do
-          func :test_myloop5, number: 56400
+    if tester.smt7?
+      loop from: 0, to: 9, step: 2, var: '$LOOP_VARIABLE1'do
+        loop from: 1, to: 10, step: 1, var: '$LOOP_VARIABLE2' do
+          loop from: 1, to: 5, step: 1, var: '$LOOP_VARIABLE3' do
+            func :test_myloop5, number: 56400
+          end
+        end
+      end
+    else
+      loop from: 0, to: 9, step: 1, var: '$LOOP_VARIABLE1'do
+        loop from: 1, to: 10, step: 1, var: '$LOOP_VARIABLE2' do
+          loop from: 1, to: 5, step: 1, var: '$LOOP_VARIABLE3' do
+            func :test_myloop5, number: 56400
+          end
         end
       end
     end
 
+    log "Tests of variable loop"
+    loop from: '$TEST_VAR', to: 1, step: -1, var: '$LOOP_VARIABLE' do
+      func :test_myloop6, number: 56500
+    end
+
     # Test of skipping variable name not yet ready
   end
 

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

@@ -17,6 +17,23 @@ 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.
 
+Optionally the defined timing can be represented in equation form by setting up your environment as follows:
+
+~~~ruby
+OrigenTesters::STIL.new use_timing_equations: true
+~~~
+
+If your application is used to convert patterns from another format into STIL format you can add
+ a callback function to config/application.rb to set appropriate period sizes as follows:
+ 
+~~~ruby
+def convert_command_set_period_in_ns(timeset_name)
+  return 25 if timeset_name == "timeset0"
+  return 30 if timeset_name == "timeset1"
+  40
+end
+~~~
+
 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: