origen 0.28.2 → 0.29.0

data/lib/origen/parameters/set.rb

@@ -179,7 +179,7 @@ module Origen
             else
               results_hash["#{name}#{delimiter}#{k}"] = v
               if k == param_hash.keys.last
-                name = nil
+                name = name.include?(delimiter) ? name.split(delimiter)[0..-2].join(delimiter) : nil
               end
             end
           end

data/lib/origen/pins.rb

@@ -227,8 +227,12 @@ module Origen
           name: ''
         }.merge(options)
 
+        rtl_name = options[:rtl_name]
+        force = options[:force]
         options.delete(:size).times do |i|
           options[:name] = "#{id}#{i}".to_sym
+          options[:rtl_name] = "#{rtl_name}#{i}".to_sym if rtl_name
+          options[:force] = force[i] if force
 
           if power_pin
             group[i] = PowerPin.new(i, self, options)

data/lib/origen/pins/function_proxy.rb

@@ -16,6 +16,14 @@ module Origen
         @pin
       end
 
+      # @api private
+      #
+      # To play nicely with == when a function proxy is wrapping a pin that is already
+      # wrapped by an OrgFile interceptor
+      def __object__
+        @pin.__object__
+      end
+
       # Intercept all calls to function-scoped attributes of the pin so
       # that we can inject the function that we want the attribute value for
       Pin::FUNCTION_SCOPED_ATTRIBUTES.each do |attribute|

data/lib/origen/pins/pin.rb

@@ -2,6 +2,17 @@ module Origen
   module Pins
     class Pin
       include PinCommon
+      include OrgFile::Interceptable
+
+      # Don't include the ! method in here, the cycle will be captured at the tester level and
+      # it would cause a double cycle in the org file if also captured at the pin
+      ORG_FILE_INTERCEPTED_METHODS = [
+        :suspend, :resume, :repeat_previous=,
+        :drive_hi, :drive_hi, :drive_very_hi, :drive_lo, :drive_lo, :drive_mem, :expect_mem,
+        :assert_hi, :expect_hi, :compare_hi, :assert_lo, :expect_lo, :compare_lo, :dont_care,
+        :drive, :assert, :compare, :expect, :assert_midband, :compare_midband, :expect_midband,
+        :toggle, :capture, :store
+      ]
 
       # Any attributes listed here will be looked up for the current function defined
       # by the current mode and configuration context before falling back to a default
@@ -37,8 +48,10 @@ module Origen
       attr_accessor :ext_pulldown
       # Pin type, either :analog or :digital
       attr_accessor :type
-      # Pin RTL name, short term solution for products that do not get full HDL path for pins
+      # Pin RTL name
       attr_accessor :rtl_name
+      # Value to be forced on the pin, e.g. during simulation
+      attr_accessor :force
 
       attr_accessor :description
       attr_accessor :notes
@@ -59,6 +72,7 @@ module Origen
         @direction = sanitize_direction(options[:direction])
         @invert = options[:invert]
         @reset = options[:reset]
+        @force = options[:force] & 1
         @id = id
         @name = options[:name]
         @rtl_name = options[:rtl_name]
@@ -75,11 +89,24 @@ module Origen
         @clock = nil
         @meta = options[:meta] || {}
         @dib_meta = options[:dib_meta] || {}
+        @_saved_state = []
+        @_saved_value = []
+        @_saved_suspend = []
+        @_saved_invert = []
+        @_saved_repeat_previous = []
         on_init(owner, options)
         # Assign the initial state from the method so that any inversion is picked up...
         send(@reset)
       end
 
+      def global_path_to
+        "dut.pins(:#{id})"
+      end
+
+      def org_file_intercepted_methods
+        ORG_FILE_INTERCEPTED_METHODS
+      end
+
       # Returns the drive cycle wave assigned to the pin based on the currently enabled timeset,
       # or nil if none is set.
       # Note that if a timeset is set then all pins will always return a wave as they will pick
@@ -90,7 +117,7 @@ module Origen
           # every cycle in some applications
           @drive_waves ||= {}
           @drive_waves[t.id] ||= {}
-          @drive_waves[t.id][code] ||= dut.current_timeset.send(:wave_for, self, type: :drive, code: code)
+          @drive_waves[t.id][code] ||= dut.current_timeset.send(:wave_for, myself, type: :drive, code: code)
         end
       end
 
@@ -104,7 +131,15 @@ module Origen
           # every cycle in some applications
           @compare_waves ||= {}
           @compare_waves[t.id] ||= {}
-          @compare_waves[t.id][code] ||= dut.current_timeset.send(:wave_for, self, type: :compare, code: code)
+          @compare_waves[t.id][code] ||= dut.current_timeset.send(:wave_for, myself, type: :compare, code: code)
+        end
+      end
+
+      def rtl_name
+        if primary_group
+          (@rtl_name || "#{primary_group.id}#{primary_group_index}").to_s
+        else
+          (@rtl_name || id).to_s
         end
       end
 
@@ -123,7 +158,7 @@ module Origen
       def hello
         drive_hi
         @@hello_pins ||= []
-        @@hello_pins << self unless @@hello_pins.include?(self)
+        @@hello_pins << myself unless @@hello_pins.include?(myself)
         @@hello_loop ||= Thread.new do
           loop do
             @@hello_pins.each(&:toggle)
@@ -141,7 +176,7 @@ module Origen
 
       # See Pin#hello
       def goodbye
-        @@hello_pins.delete(self)
+        @@hello_pins.delete(myself)
         puts "Pin #{name} has stopped toggling"
       end
 
@@ -244,7 +279,7 @@ module Origen
       #   pin.expect_lo
       #   pin.to_vector   # => "L"
       def to_vector
-        @vector_formatted_value ||= Origen.tester.format_pin_state(self)
+        @vector_formatted_value ||= Origen.tester.format_pin_state(myself)
       end
 
       # @api private
@@ -266,13 +301,13 @@ module Origen
       #   pin.value                         # => 1
       def vector_formatted_value=(val)
         unless @vector_formatted_value == val
-          Origen.tester.update_pin_from_formatted_state(self, val)
+          Origen.tester.update_pin_from_formatted_state(myself, val)
           @vector_formatted_value = val
         end
       end
 
       def inspect
-        "<#{self.class}:#{object_id}>"
+        "<#{myself.class}:#{object_id}>"
       end
 
       def describe(options = {})
@@ -368,7 +403,7 @@ module Origen
       def groups
         # Origen.pin_bank.all_pin_groups.select do |name, group|
         @groups ||= Origen.pin_bank.pin_groups.select do |_name, group|
-          group.include?(self)
+          group.include?(myself)
         end
       end
       alias_method :pin_groups, :groups
@@ -391,8 +426,8 @@ module Origen
         else
           packages.each do |package_id|
             package_id = package_id.respond_to?(:id) ? package_id.id : package_id
-            self.packages[package_id] ||= {}
-            self.packages[package_id][:location] = str
+            myself.packages[package_id] ||= {}
+            myself.packages[package_id][:location] = str
             add_alias str.to_s.symbolize, package: package_id, mode: :all, configuration: :all
           end
         end
@@ -412,9 +447,9 @@ module Origen
         else
           packages.each do |package_id|
             package_id = package_id.respond_to?(:id) ? package_id.id : package_id
-            self.packages[package_id] ||= {}
-            self.packages[package_id][:dib_assignment] ||= []
-            self.packages[package_id][:dib_assignment][options[:site]] = str
+            myself.packages[package_id] ||= {}
+            myself.packages[package_id][:dib_assignment] ||= []
+            myself.packages[package_id][:dib_assignment][options[:site]] = str
             add_alias str.to_s.symbolize, package: package_id, mode: :all, configuration: :all
           end
         end
@@ -468,7 +503,7 @@ module Origen
       def add_function(id, options = {})
         id = id.to_sym
         add_function_attributes(options.merge(name: id, id: id.to_sym))
-        f = FunctionProxy.new(id, self)
+        f = FunctionProxy.new(id, myself)
         add_alias id, packages: :all, obj: f
       end
 
@@ -510,7 +545,7 @@ module Origen
       # If the options contain a package, mode or configuration reference then the alias
       # will only work under that context.
       def add_alias(id, options = {})
-        obj = options.delete(:obj) || self
+        obj = options.delete(:obj) || myself
         if aliases[id]
           aliases[id][:packages] += resolve_packages(options)
           aliases[id][:modes] += resolve_modes(options)
@@ -556,7 +591,7 @@ module Origen
       # Returns true if the pin is an alias of the given pin name
       def is_alias_of?(name)
         if Origen.pin_bank.find(name)
-          Origen.pin_bank.find(name).id == Origen.pin_bank.find(self).id
+          Origen.pin_bank.find(name).id == Origen.pin_bank.find(myself).id
         else
           false
         end
@@ -610,18 +645,32 @@ module Origen
       end
 
       def set_value(val)
+        orig = val
         invalidate_vector_cache
         if val.is_a?(String) || val.is_a?(Symbol)
-          @vector_formatted_value = val.to_s
+          val = val.to_s
+          if val =~ /^(b|h).+/
+            val = Origen::Value.new(val)
+          else
+            @vector_formatted_value = val
+            return
+          end
+        end
+        if val.is_a?(Origen::Value)
+          val = val[0]
         else
           # If val is a data bit extract the value of it
           val = val.respond_to?(:data) ? val.data : val
           # Assume driving/asserting a nil value means 0
           val = 0 unless val
-          if val > 1
+          if !val.x_or_z? && val > 1
             fail "Attempt to set a value of #{val} on pin #{name}"
           end
-          @repeat_previous = false
+        end
+        @repeat_previous = false
+        if val.x_or_z?
+          dont_care
+        else
           if inverted?
             @value = val == 0 ? 1 : 0
           else
@@ -719,9 +768,9 @@ module Origen
         # options = { :active => false    #if active true means to take tester active load capability into account
         #          }.merge(options)
         # unless state_to_be_inverted?
-        #  self.state = ($tester.active_loads || !options[:active]) ? $tester.pin_state(:expect_lo) : $tester.pin_state(:dont_care)
+        #  myself.state = ($tester.active_loads || !options[:active]) ? $tester.pin_state(:expect_lo) : $tester.pin_state(:dont_care)
         # else
-        #  self.state = ($tester.active_loads || !options[:active]) ? $tester.pin_state(:expect_hi) : $tester.pin_state(:dont_care)
+        #  myself.state = ($tester.active_loads || !options[:active]) ? $tester.pin_state(:expect_hi) : $tester.pin_state(:dont_care)
         # end
       end
       alias_method :expect_lo, :assert_lo
@@ -881,21 +930,24 @@ module Origen
         restore
       end
 
-      def save # :nodoc:
-        @_saved_state = @state
-        @_saved_value = @value
-        @_saved_suspend = @suspend
-        @_saved_invert = @invert
-        @_saved_repeat_previous = @repeat_previous
+      # Saves the current state of the pin, allowing it to be restored to the
+      # current state by calling the restore method
+      def save
+        @_saved_state << @state
+        @_saved_value << @value
+        @_saved_suspend << @suspend
+        @_saved_invert << @invert
+        @_saved_repeat_previous << @repeat_previous
       end
 
-      def restore # :nodoc:
+      # Restores the state of the pin to the last time save was called
+      def restore
         invalidate_vector_cache
-        @state = @_saved_state
-        @value = @_saved_value
-        @suspend = @_saved_suspend
-        @invert = @_saved_invert
-        @repeat_previous = @_saved_repeat_previous
+        @state = @_saved_state.pop
+        @value = @_saved_value.pop
+        @suspend = @_saved_suspend.pop
+        @invert = @_saved_invert.pop
+        @repeat_previous = @_saved_repeat_previous.pop
       end
 
       def is_not_a_clock?
@@ -911,7 +963,7 @@ module Origen
       end
 
       def enable_clock(options = {})
-        @clock = PinClock.new(self, options)
+        @clock = PinClock.new(myself, options)
       end
 
       def disable_clock(options = {})
@@ -924,7 +976,7 @@ module Origen
       end
 
       def start_clock(options = {})
-        enable_clock(options) if self.is_not_a_clock?
+        enable_clock(options) if myself.is_not_a_clock?
         @clock.start_clock(options)
       end
       alias_method :resume_clock, :start_clock
@@ -951,12 +1003,12 @@ module Origen
         @clock.toggle
       end
 
-      # Delete this pin (self).  Used bang in method name to keep same for pins and
+      # Delete this pin (myself).  Used bang in method name to keep same for pins and
       # pin collections.  Pin collections already had a delete method which deletes
       # a pin from the collection.  Needed delete! to indicate it is deleting the
       # actual pin or pin group calling the method.
       def delete!
-        owner.delete_pin(self)
+        owner.delete_pin(myself)
       end
 
       def type=(value)

data/lib/origen/pins/pin_collection.rb

@@ -5,6 +5,14 @@ module Origen
     class PinCollection
       include PinCommon
       include Enumerable
+      include OrgFile::Interceptable
+
+      ORG_FILE_INTERCEPTED_METHODS = [
+        :drive, :drive_hi, :drive_lo, :drive_very_hi, :drive_mem, :expect_mem, :toggle,
+        :repeat_previous=, :capture, :assert, :compare, :expect,
+        :assert_hi, :expect_hi, :compare_hi, :assert_lo, :expect_lo, :compare_lo,
+        :dont_care
+      ]
 
       attr_accessor :endian
       attr_accessor :description
@@ -22,6 +30,7 @@ module Origen
         @virtual_pins = options.delete(:virtual_pin) || options.delete(:virtual_pins)
         @other_pins = options.delete(:other_pin) || options.delete(:other_pins)
         @endian = options[:endian]
+        @rtl_name = options[:rtl_name]
         @description = options[:description] || options[:desc]
         @options = options
         @store = []
@@ -31,6 +40,18 @@ module Origen
         on_init(owner, options)
       end
 
+      def rtl_name
+        (@rtl_name || id).to_s
+      end
+
+      def global_path_to
+        "dut.pins(:#{id})"
+      end
+
+      def org_file_intercepted_methods
+        ORG_FILE_INTERCEPTED_METHODS
+      end
+
       # Returns the value held by the pin group as a string formatted to the current tester's pattern syntax
       #
       # @example
@@ -70,7 +91,7 @@ module Origen
             fail 'When setting vector_formatted_value on a pin group you must supply values for all pins!'
           end
           val.split(//).reverse.each_with_index do |val, i|
-            self[i].vector_formatted_value = val
+            myself[i].vector_formatted_value = val
           end
           @vector_formatted_value = val
         end
@@ -140,12 +161,12 @@ module Origen
 
       def sort!(&block)
         @store = sort(&block)
-        self
+        myself
       end
 
       def sort_by!
         @store = sort_by
-        self
+        myself
       end
 
       def []=(index, pin)
@@ -207,11 +228,11 @@ module Origen
       alias_method :<<, :add_pin
 
       def drive(val)
-        val = val.data if val.respond_to?('data')
+        value = clean_value(value)
         each_with_index do |pin, i|
           pin.drive(val[size - i - 1])
         end
-        self
+        myself
       end
 
       def drive!(val)
@@ -222,7 +243,7 @@ module Origen
       # Set all pins in pin group to drive 1's on future cycles
       def drive_hi
         each(&:drive_hi)
-        self
+        myself
       end
 
       def drive_hi!
@@ -233,7 +254,7 @@ module Origen
       # Set all pins in pin group to drive 0's on future cycles
       def drive_lo
         each(&:drive_lo)
-        self
+        myself
       end
 
       def drive_lo!
@@ -245,7 +266,7 @@ module Origen
       # For example on a J750 high-voltage channel the pin state would be set to "2"
       def drive_very_hi
         each(&:drive_very_hi)
-        self
+        myself
       end
 
       def drive_very_hi!
@@ -255,7 +276,7 @@ module Origen
 
       def drive_mem
         each(&:drive_mem)
-        self
+        myself
       end
 
       def drive_mem!
@@ -265,7 +286,7 @@ module Origen
 
       def expect_mem
         each(&:expect_mem)
-        self
+        myself
       end
 
       def expect_mem!
@@ -293,7 +314,7 @@ module Origen
 
       def toggle
         each(&:toggle)
-        self
+        myself
       end
 
       def toggle!
@@ -303,13 +324,13 @@ module Origen
 
       def repeat_previous=(bool)
         each { |pin| pin.repeat_previous = bool }
-        self
+        myself
       end
 
       # Mark the (data) from all the pins in the pin group to be captured
       def capture
         each(&:capture)
-        self
+        myself
       end
       alias_method :store, :capture
 
@@ -320,8 +341,16 @@ module Origen
       alias_method :store!, :capture!
 
       def restore_state
-        each(&:save)
+        save
         yield
+        restore
+      end
+
+      def save
+        each(&:save)
+      end
+
+      def restore
         each(&:restore)
       end
 
@@ -334,6 +363,7 @@ module Origen
       end
 
       def assert(value, options = {})
+        value = clean_value(value)
         each_with_index do |pin, i|
           if !value.respond_to?('data')
             pin.assert(value[size - i - 1], options)
@@ -343,7 +373,7 @@ module Origen
             pin.dont_care
           end
         end
-        self
+        myself
       end
       alias_method :compare, :assert
       alias_method :expect, :assert
@@ -358,7 +388,7 @@ module Origen
       # Set all pins in the pin group to expect 1's on future cycles
       def assert_hi(options = {})
         each { |pin| pin.assert_hi(options) }
-        self
+        myself
       end
       alias_method :expect_hi, :assert_hi
       alias_method :compare_hi, :assert_hi
@@ -373,7 +403,7 @@ module Origen
       # Set all pins in the pin group to expect 0's on future cycles
       def assert_lo(options = {})
         each { |pin| pin.assert_lo(options) }
-        self
+        myself
       end
       alias_method :expect_lo, :assert_lo
       alias_method :compare_lo, :assert_lo
@@ -388,7 +418,7 @@ module Origen
       # Set all pins in the pin group to X on future cycles
       def dont_care
         each(&:dont_care)
-        self
+        myself
       end
 
       def dont_care!
@@ -456,13 +486,23 @@ pins(:some_group).map(&:id).sort
         end
       end
 
-      # Delete this pingroup (self)
+      # Delete this pingroup (myself)
       def delete!
-        owner.delete_pin(self)
+        owner.delete_pin(myself)
       end
 
       private
 
+      def clean_value(val)
+        return val if val.respond_to?(:contains_bits?)
+        val = val.data if val.respond_to?('data')
+        if val.is_a?(String) || val.is_a?(Symbol)
+          Origen::Value.new(val)
+        else
+          val
+        end
+      end
+
       # Cleans up indexed references to pins, e.g. makes these equal:
       #
       #   pins(:pb)[0,1,2,3]
@@ -501,7 +541,7 @@ pins(:some_group).map(&:id).sort
           else
             # Allow getters if all pins are the same
             ref = first.send(method, *args)
-            if self.all? { |pin| pin.send(method, *args) == ref }
+            if myself.all? { |pin| pin.send(method, *args) == ref }
               ref
             else
               fail "The pins held by pin collection #{id} have different values for #{method}"