origen 0.0.1 → 0.0.2

data/lib/origen/pins/port.rb

@@ -0,0 +1,268 @@
+module Origen
+  module Pins
+    class Port
+      attr_accessor :name
+      attr_reader :id
+      attr_reader :owner
+      attr_reader :size
+      attr_accessor :order
+
+      include Pins
+
+      def initialize(id, owner, options = {})
+        options = {
+          name:     id.to_s,
+          endian:   :big,
+          add_pins: true
+        }.merge(options)
+        @endian = options.delete(:endian)
+        @size = options.delete(:size)
+        @name = options.delete(:name)
+        @order = options.delete(:order)
+        @id = id
+        @owner = owner
+        add_pins(options) if options[:add_pins]
+      end
+
+      def name
+        (Origen.app.pin_names[id] || @name).to_s
+      end
+
+      def inspect
+        "<#{self.class}:#{object_id}>"
+      end
+
+      def add_pins(options)
+        size.times do |i|
+          ix = @endian == :big ? @size - i - 1 : i
+          pin = add_pin(ix, options)
+          pin.port = self
+        end
+      end
+
+      def cycle # :nodoc:
+        Origen.tester.cycle
+      end
+
+      def drive_mem
+        pins.each { |_ix, pin| pin.drive_mem }
+      end
+
+      def drive_mem!
+        drive_mem
+        cycle
+      end
+
+      def expect_mem
+        pins.each { |_ix, pin| pin.expect_mem }
+      end
+
+      def expect_mem!
+        expect_mem
+        cycle
+      end
+
+      # Set the pin to drive a 1 on future cycles
+      def drive_hi
+        pins.each { |_ix, pin| pin.drive_hi }
+      end
+
+      def drive_hi!
+        drive_hi
+        cycle
+      end
+
+      # Set the pin to drive a high voltage on future cycles (if the tester supports it).
+      # For example on a J750 high-voltage channel the pin state would be set to "2"
+      def drive_very_hi
+        pins.each { |_ix, pin| pin.drive_very_hi }
+      end
+
+      def drive_very_hi!
+        drive_very_hi
+        cycle
+      end
+
+      # Set the pin to drive a 0 on future cycles
+      def drive_lo
+        pins.each { |_ix, pin| pin.drive_lo }
+      end
+
+      def drive_lo!
+        drive_lo
+        cycle
+      end
+
+      # Set the pin to expect a 1 on future cycles
+      def assert_hi(_options = {})
+        pins.each { |_ix, pin| pin.assert_hi }
+      end
+      alias_method :compare_hi, :assert_hi
+      alias_method :expect_hi, :assert_hi
+
+      def assert_hi!
+        assert_hi
+        cycle
+      end
+      alias_method :compare_hi!, :assert_hi!
+      alias_method :expect_hi!, :assert_hi!
+
+      # Set the pin to expect a 0 on future cycles
+      def assert_lo(_options = {})
+        pins.each { |_ix, pin| pin.assert_lo }
+      end
+      alias_method :compare_lo, :assert_lo
+      alias_method :expect_lo, :assert_lo
+
+      def assert_lo!
+        assert_lo
+        cycle
+      end
+      alias_method :compare_lo!, :assert_lo!
+      alias_method :expect_lo!, :assert_lo!
+
+      # Set the pin to X on future cycles
+      def dont_care
+        pins.each { |_ix, pin| pin.dont_care }
+      end
+
+      def dont_care!
+        dont_care
+        cycle
+      end
+
+      # Pass in 0 or 1 to have the pin drive_lo or drive_hi respectively.
+      # This is useful when programatically setting the pin state.
+      # ==== Example
+      #   [0,1,1,0].each do |level|
+      #       $pin(:d_in).drive(level)
+      #   end
+      def drive(value)
+        size.times do |i|
+          pins[i].drive(value[i])
+        end
+      end
+
+      def drive!(value)
+        drive(value)
+        cycle
+      end
+
+      # Pass in 0 or 1 to have the pin expect_lo or expect_hi respectively.
+      # This is useful when programatically setting the pin state.
+      # ==== Example
+      #   [0,1,1,0].each do |level|
+      #       $pin(:d_in).assert(level)
+      #   end
+      def assert(value, _options = {})
+        size.times do |i|
+          pins[i].expect(value[i])
+        end
+      end
+      alias_method :compare, :assert
+      alias_method :expect, :assert
+
+      def assert!(*args)
+        assert(*args)
+        cycle
+      end
+
+      def [](ix)
+        pins[ix]
+      end
+
+      # Returns the data value currently assigned to the port
+      def data
+        d = 0
+        size.times do |i|
+          d |= pins[i].data << i
+        end
+        d
+      end
+      alias_method :value, :data
+
+      # Returns the inverse of the data value currently assigned to the port
+      def data_b
+        # (& operation takes care of Bignum formatting issues)
+        ~data & ((1 << size) - 1)
+      end
+      alias_method :value_b, :data_b
+
+      # Set the data assigned to the port
+      def data=(val)
+        size.times do |i|
+          pins[i].data = val[i]
+        end
+      end
+
+      def toggle
+        self.data = data_b
+      end
+
+      def toggle!
+        toggle
+        cycle
+      end
+
+      def comparing?
+        pins.any? { |_ix, pin| pin.comparing? }
+      end
+
+      def comparing_mem?
+        pins.any? { |_ix, pin| pin.comparing_mem? }
+      end
+
+      def driving?
+        pins.any? { |_ix, pin| pin.driving? }
+      end
+
+      def driving_mem?
+        pins.any? { |_ix, pin| pin.driving_mem? }
+      end
+
+      def high_voltage?
+        pins.any? { |_ix, pin| pin.high_voltage? }
+      end
+
+      def repeat_previous=(bool)
+        pins.each { |_ix, pin| pin.repeat_previous = bool }
+      end
+
+      # Mark the (data) from the port to be captured
+      def capture
+        pins.each { |_ix, pin| pin.capture }
+      end
+      alias_method :store, :capture
+
+      # Mark the (data) from the port to be captured and trigger a cycle
+      def capture!
+        capture
+        cycle
+      end
+      alias_method :store!, :capture!
+
+      # Returns true if the (data) from the port is marked to be captured
+      def to_be_captured?
+        pins.any? { |_ix, pin| pin.to_be_captured? }
+      end
+      alias_method :to_be_stored?, :to_be_captured?
+      alias_method :is_to_be_stored?, :to_be_captured?
+      alias_method :is_to_be_captured?, :to_be_captured?
+
+      # Restores the state of the port at the end of the given block
+      # to the state it was in at the start of the block
+      #
+      #   port(:a).driving?  # => true
+      #   port(:a).restore_state do
+      #     port(:a).dont_care
+      #     port(:a).driving?  # => false
+      #   end
+      #   port(:a).driving?  # => true
+      def restore_state
+        pins.each { |_ix, pin| pin.save }
+        yield
+        pins.each { |_ix, pin| pin.restore }
+      end
+    end
+  end
+end

data/lib/origen/pins/power_pin.rb

@@ -0,0 +1,30 @@
+module Origen
+  module Pins
+    class PowerPin < Pin
+      # Set the operating voltage for the pin, can be a single value or an array
+      def voltage=(val)
+        @voltages = [val].flatten.uniq
+      end
+
+      # Like voltages but if there is only one voltage known then it will be returned
+      # directly instead of being wrapped in an array.
+      # If no voltages are known this returns nil whereas voltages will return an
+      # empty array.
+      # For more than one voltages present this behaves like an alias of voltages.
+      def voltage
+        if voltages.size > 0
+          if voltages.size > 1
+            voltages
+          else
+            voltages.first
+          end
+        end
+      end
+
+      # Returns an array of known operating voltages for the given pin
+      def voltages
+        @voltages ||= []
+      end
+    end
+  end
+end