origen 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2b03ec3627ba26fc085e2a5302472d6bf13522bb
-  data.tar.gz: e915a39f3b40a64aa4255b13293570b37abdd765
+  metadata.gz: 7f8ba64d3b0ecc75adf1a8d9e494db97b7367cc5
+  data.tar.gz: 6552aebba7e09bf8ad59ea4d5cd75f75395c6adf
 SHA512:
-  metadata.gz: 958952409ba581f177774cc2dbe23eb42cc018fdf64eca2faa1708f7356c73beebc886678c4cb0fb6e8d7fac726f1fc20979cd7e233ced7d848a7724a8fd92bb
-  data.tar.gz: 5ad6fb24cdf7c84f05bf7cc854c917e63e86c29eb133eee45f6e5ced7ac870ca108be1a0dcc4456af8f0d7f9696cecfe9103a4a76632ffc88eaf7a2a73360cab
+  metadata.gz: 3093953c422bf77ff2bc60af0878aab13f49a0f1b6911555a6ee7958b3ce5bed3bf5266c157d6ace7ef8c2af98f8d0d7cff6d7454cdca9118db3a79cdaf3bb67
+  data.tar.gz: 7a54ad39e2cb1c0c5ba1c9b86fc420c620e0aee9a2b8d8e6f937181a5307fed6bc53b3aae69c948afc191a59cac8562d98ee18dc6f564d31d6398c8805fc4024

data/config/version.rb

@@ -1,6 +1,6 @@
 module Origen
   MAJOR = 0
-  MINOR = 11
+  MINOR = 12
   BUGFIX = 0
   DEV = nil
 

data/lib/origen/pins/pin.rb

@@ -79,6 +79,34 @@ module Origen
         send(@reset)
       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
+      # up a default waveform if none is explicitly assigned to it.
+      def drive_wave(code = nil)
+        if t = dut.current_timeset
+          # Cache this for performance since potentially this is something that could be called on
+          # 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)
+        end
+      end
+
+      # Returns the compare 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
+      # up a default waveform if none is explicitly assigned to it.
+      def compare_wave(code = nil)
+        if t = dut.current_timeset
+          # Cache this for performance since potentially this is something that could be called on
+          # 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)
+        end
+      end
+
       # Causes the pin to continuously drive 1 for 2 seconds and then drive 0 for 2 seconds.
       #
       # This is not an API that is intended to be used within a pattern. Rather it is a debug aid when
@@ -321,6 +349,20 @@ module Origen
         end
       end
 
+      # If the pin was defined initially as part of a group then this will return that group,
+      # otherwise it will return nil
+      def group
+        @primary_group
+      end
+      alias_method :primary_group, :group
+
+      # If the pin is a member of a primary group, this returns its index number within that
+      # group, otherwise returns nil
+      def group_index
+        @primary_group_index
+      end
+      alias_method :primary_group_index, :group_index
+
       # Returns a hash containing the pin groups that the given pin is a member of
       def groups
         # Origen.pin_bank.all_pin_groups.select do |name, group|
@@ -556,18 +598,22 @@ module Origen
 
       def set_value(val)
         invalidate_vector_cache
-        # 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
-          fail "Attempt to set a value of #{val} on pin #{name}"
-        end
-        @repeat_previous = false
-        if inverted?
-          @value = val == 0 ? 1 : 0
+        if val.is_a?(String) || val.is_a?(Symbol)
+          @vector_formatted_value = val.to_s
         else
-          @value = val
+          # 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
+            fail "Attempt to set a value of #{val} on pin #{name}"
+          end
+          @repeat_previous = false
+          if inverted?
+            @value = val == 0 ? 1 : 0
+          else
+            @value = val
+          end
         end
       end
       alias_method :data=, :set_value
@@ -931,6 +977,16 @@ module Origen
           fail "Pin ext_pulldown  attribute '#{value}' must be either true or false"
         end
       end
+
+      private
+
+      def primary_group=(group)
+        @primary_group = group
+      end
+
+      def primary_group_index=(number)
+        @primary_group_index = number
+      end
     end
   end
 end

data/lib/origen/pins/timing/timeset.rb

@@ -0,0 +1,169 @@
+module Origen
+  module Pins
+    module Timing
+      class Timeset
+        attr_reader :id
+
+        # Returns an array containing the defined waves for drive cycles.
+        # The wave at position 0 will be applied be default to any pin which
+        # does not otherwise have a specific wave assignment.
+        attr_reader :drive_waves
+
+        # Returns an array containing the defined waves for compare cycles
+        # The wave at position 0 will be applied be default to any pin which
+        # does not otherwise have a specific wave assignment.
+        attr_reader :compare_waves
+
+        def initialize(id)
+          @id = id
+          @drive_waves = []
+          @compare_waves = []
+          # Look up tables that map pins to waves
+          @compare_pin_map = {}
+          @drive_pin_map = {}
+          # Temporary storage of pin assignments
+          @pin_ids = { drive: [], compare: [] }
+
+          # Create the default waves, these can be overridden later
+          wave do |w|
+            w.compare :data, at: 'period / 2'
+          end
+
+          wave do |w|
+            w.drive :data, at: 0
+          end
+        end
+
+        # Add a new drive or compare wave to the timeset
+        #
+        #   timeset.wave :tck do |w|
+        #     w.drive :data, at: 0
+        #     w.drive 0, at: 25
+        #     w.dont_care at: "period - 10"
+        #   end
+        def wave(*pin_ids)
+          options = pin_ids.last.is_a?(Hash) ? pin_ids.pop : {}
+          w = Wave.new(self, options)
+          yield w
+          if w.drive?
+            if pin_ids.empty?
+              w.send(:index=, 0)
+              drive_waves[0] = w
+              @pin_ids[:drive][0] = pin_ids
+            else
+              w.send(:index=, drive_waves.size)
+              drive_waves << w
+              @pin_ids[:drive] << pin_ids
+            end
+          else
+            if pin_ids.empty?
+              w.send(:index=, 0)
+              compare_waves[0] = w
+              @pin_ids[:compare][0] = pin_ids
+            else
+              w.send(:index=, compare_waves.size)
+              compare_waves << w
+              @pin_ids[:compare] << pin_ids
+            end
+          end
+        end
+        alias_method :compare_wave, :wave
+        alias_method :drive_wave, :wave
+
+        # The timeset will cache a view of the dut's pins for performance,
+        # calling this method will clear that cache and regenerate the internal
+        # view. This should generally not be required, but available for corner cases
+        # where a pin is added to the dut after the cache has been generated.
+        def clear_cache
+          @all_pin_ids = nil
+          @groups = nil
+          compare_waves.each { |w| w.send(:clear_cache) }
+          drive_waves.each { |w| w.send(:clear_cache) }
+        end
+
+        private
+
+        # The pin assignments are done lazily to cater for the guy who will want
+        # to define waves ahead of pins or some such
+        def assign_pins
+          @pin_ids[:drive].each_with_index do |ids, i|
+            expand_groups(ids) do |id|
+              @drive_pin_map[id] ||= []
+              @drive_pin_map[id] << i
+            end
+          end
+          @pin_ids[:compare].each_with_index do |ids, i|
+            expand_groups(ids) do |id|
+              @compare_pin_map[id] ||= []
+              @compare_pin_map[id] << i
+            end
+          end
+          @pin_ids = :done
+        end
+
+        def expand_groups(ids)
+          ids.each do |id|
+            if g = dut.pin_groups[id]
+              g.each do |pin|
+                yield pin.id
+              end
+            else
+              yield id
+            end
+          end
+        end
+
+        def wave_for(pin, options)
+          assign_pins unless @pin_ids == :done
+          if options[:type] == :drive
+            i = @drive_pin_map[pin.id]
+            if i
+              if i.size > 1
+                code = options[:code]
+                code = nil if code == 1
+                code = nil if code == 0
+                i.each do |ix|
+                  return drive_waves[ix] if drive_waves[ix].code == code
+                end
+              else
+                drive_waves[i[0]]
+              end
+            else
+              drive_waves[0]
+            end
+          else
+            i = @compare_pin_map[pin.id]
+            if i
+              if i.size > 1
+                code = options[:code]
+                code = nil if code == 'L' || code == :L
+                code = nil if code == 'H' || code == :H
+                i.each do |ix|
+                  return drive_waves[ix] if drive_waves[ix].code == code
+                end
+              else
+                compare_waves[i[0]]
+              end
+            else
+              compare_waves[0]
+            end
+          end
+        end
+
+        def pin_ids_for(wave)
+          assign_pins unless @pin_ids == :done
+          map = wave.drive? ? @drive_pin_map : @compare_pin_map
+          if wave.index == 0
+            all_pin_ids.select { |id| !map[id] || map[id].include?(0) }
+          else
+            all_pin_ids.select { |id| map[id] && map[id].include?(wave.index) }
+          end
+        end
+
+        def all_pin_ids
+          @all_pin_ids ||= dut.pins.values.map(&:id)
+        end
+      end
+    end
+  end
+end

data/lib/origen/pins/timing/wave.rb

@@ -0,0 +1,147 @@
+module Origen
+  module Pins
+    module Timing
+      class Wave
+        attr_reader :events, :timeset, :index
+        # Returns the pattern code value associated with the wave. By default this will return nil
+        # if no code was given at the time the wave was defined, which means it is the wave that will
+        # be applied for the conventional code values of 0, 1, H, L.
+        attr_reader :code
+
+        VALID_DRIVE_DATA = [0, 1, :data]
+        VALID_COMPARE_DATA = [0, 1, :data]
+
+        def initialize(timeset, options = {})
+          @code = options[:code]
+          @code = nil if [0, 1, 'H', 'L', :H, :L].include?(@code)
+          @timeset = timeset
+          @events = []
+        end
+
+        # Returns the events array but with any formula based times
+        # evaluated.
+        # Note that this does not raise an error if the period is not currently
+        # set, in that case any events that reference it will have nil for
+        # their time.
+        def evaluated_events
+          if dut.current_timeset_period
+            events.map { |e| [calc.evaluate(e[0], period: dut.current_timeset_period).ceil, e[1]] }
+          else
+            fail 'The current timeset period has not been set'
+          end
+        end
+
+        # Returns an array containing all dut pin_ids that
+        # are assigned to this wave by the parent timeset
+        def pin_ids
+          @pins_ids ||= timeset.send(:pin_ids_for, self)
+        end
+
+        # Returns an array containing all dut pin objects that
+        # are assigned to this wave by the parent timeset
+        def pins
+          @pins ||= pin_ids.map { |id| dut.pin(id) }
+        end
+
+        def drive(data, options)
+          self.type = :drive
+          validate_data(data) do |d|
+            validate_time(options) do |t|
+              events << [t, d]
+            end
+          end
+        end
+
+        def compare(data, options)
+          self.type = :compare
+          validate_data(data) do |d|
+            validate_time(options) do |t|
+              events << [t, d]
+            end
+          end
+        end
+        alias_method :compare_edge, :compare
+
+        def dont_care(options)
+          self.type = :drive
+          validate_time(options) do |t|
+            events << [t, :x]
+          end
+        end
+        alias_method :highz, :dont_care
+
+        def type
+          @type ||= :drive
+        end
+
+        def drive?
+          @type == :drive
+        end
+
+        def compare?
+          @type == :compare
+        end
+
+        private
+
+        def clear_cache
+          @pin_ids = nil
+          @pins = nil
+        end
+
+        def index=(val)
+          @index = val
+        end
+
+        def validate_data(data)
+          valid = drive? ? VALID_DRIVE_DATA : VALID_COMPARE_DATA
+          data = :data if :data == :pattern
+          unless valid.include?(data)
+            fail "Uknown data value #{data}, only these are valid: #{valid.join(', ')}"
+          end
+          yield data
+        end
+
+        def calc
+          return @calc if @calc
+          require 'dentaku'
+          @calc = Dentaku::Calculator.new
+        end
+
+        def type=(t)
+          if @type
+            if @type != t
+              fail 'Timing waves cannot both drive and compare within a cycle period!'
+            end
+          else
+            @type = t
+          end
+        end
+
+        def validate_time(options)
+          unless options[:at]
+            fail 'When defining a wave event you must supply the time via the option :at'
+          end
+          t = options[:at]
+
+          if t.is_a?(String)
+            d = calc.dependencies(t) - %w(period period_in_ns)
+            unless d.empty?
+              fail "Wave time formulas can only include the variable 'period' (or 'period_in_ns'), this variable is not allowed: #{d}"
+            end
+            t = t.gsub('period_in_ns', 'period')
+            unless calc.evaluate(t, period: 100)
+              fail "There appears to be an error in the formula: #{t}"
+            end
+            yield t
+            return
+          elsif t.is_a?(Numeric)
+            yield t
+            return
+          end
+          fail 'The :at option in a wave event definition must be either a number or a string'
+        end
+      end
+    end
+  end
+end

data/lib/origen/pins/timing.rb

@@ -0,0 +1,76 @@
+module Origen
+  module Pins
+    # Top-level manager for the devices pin timing setups,
+    # an instance of this class is automatically instantiated
+    # and available as dut.timing
+    module Timing
+      autoload :Timeset,     'origen/pins/timing/timeset'
+      autoload :Wave,        'origen/pins/timing/wave'
+
+      # Add a very basic timeset where all pins will have default waves,
+      # which will drive for the whole cycle and compare at 50% of the
+      # current period
+      #
+      #   add_timeset :func
+      def add_timeset(*args, &block)
+        if block_given?
+          timesets(*args, &block)
+        else
+          timesets(args.first) {}
+        end
+      end
+
+      def timesets(name = nil, options = {})
+        name, options = nil, name if name.is_a?(Hash)
+        @timesets ||= {}.with_indifferent_access
+        # If defining a new timeset
+        if block_given?
+          @timesets[name] ||= Timeset.new(name)
+          yield @timesets[name]
+        else
+          if name
+            @timesets[name]
+          else
+            @timesets
+          end
+        end
+      end
+
+      # Returns the currently selected timeset, or nil
+      def current_timeset(*args, &block)
+        if block_given?
+          timesets(*args, &block)
+        else
+          if args.first
+            timesets(args.first)
+          else
+            timesets[@current_timeset]
+          end
+        end
+      end
+      alias_method :timeset, :current_timeset
+
+      # Set the current timeset, this will be called automatically
+      # if the timeset is changed via tester.set_timeset
+      def current_timeset=(id)
+        if timesets[id]
+          @current_timeset = id
+        else
+          fail "Timeset #{id} has not been defined!"
+        end
+      end
+      alias_method :timeset=, :current_timeset=
+
+      # Set the current timeset period, this will be called automatically
+      # if the timeset is changed via tester.set_timeset
+      def current_timeset_period=(val)
+        @current_timeset_period = val
+      end
+
+      # Returns the current timeset period or nil
+      def current_timeset_period
+        @current_timeset_period
+      end
+    end
+  end
+end

data/lib/origen/pins.rb

@@ -179,6 +179,9 @@ module Origen
     autoload :OtherPin,      'origen/pins/other_pin'
     autoload :VirtualPin,    'origen/pins/virtual_pin'
     autoload :FunctionProxy, 'origen/pins/function_proxy'
+    require 'origen/pins/timing'
+
+    include Timing
 
     # @api private
     # API v2, deprecated
@@ -242,7 +245,9 @@ module Origen
         end
         yield group if block_given?
         group.each do |pin|
+          pin.send(:primary_group_index=, pin.id)
           pin.id = "#{group.id}#{pin.id}".to_sym
+          pin.send(:primary_group=, group)
           pin.finalize
         end
         if group.size == 1

data/lib/origen/registers/bit_collection.rb

@@ -104,7 +104,7 @@ module Origen
       # not intended to be inserted into production pattern logic.
       def sync(size = nil, options = {})
         size, options = nil, size if size.is_a?(Hash)
-        if tester.try(:link?)
+        if tester.respond_to?(:capture)
           preserve_flags do
             v = tester.capture do
               store!(sync: true)

data/lib/origen/top_level.rb

@@ -24,6 +24,11 @@ module Origen
       include Origen::Model
     end
 
+    # Top-level timing manager/API, returns an instance of Origen::Pins::Timing
+    def timing
+      @timing ||= Pins::Timing.new
+    end
+
     def reset!
       reset bang: true
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: origen
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Stephen McGinty
@@ -338,6 +338,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: dentaku
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
 description: 
 email:
 - stephen.f.mcginty@gmail.com
@@ -486,6 +500,9 @@ files:
 - lib/origen/pins/pin_collection.rb
 - lib/origen/pins/pin_common.rb
 - lib/origen/pins/power_pin.rb
+- lib/origen/pins/timing.rb
+- lib/origen/pins/timing/timeset.rb
+- lib/origen/pins/timing/wave.rb
 - lib/origen/pins/virtual_pin.rb
 - lib/origen/ports.rb
 - lib/origen/ports/bit_collection.rb