origen_testers 0.13.2 → 0.14.0

data/lib/origen_testers/labview_based_tester.rb

@@ -0,0 +1,7 @@
+module OrigenTesters
+  module LabVIEWBasedTester
+    autoload :Pxie6570,		'origen_testers/labview_based_tester/pxie6570.rb'
+  end
+  # Shorter name without LabVIEWBasedTester namespace
+  autoload :Pxie6570,		'origen_testers/labview_based_tester/pxie6570.rb'
+end

data/lib/origen_testers/labview_based_tester/pxie6570.rb

@@ -0,0 +1,190 @@
+module OrigenTesters
+  module LabVIEWBasedTester
+    class Pxie6570
+      include OrigenTesters::VectorBasedTester
+
+      attr_accessor :default_source_wave_name, :default_capture_wave_name
+
+      def initialize
+        @pat_extension = 'digipatsrc'
+        @capture_started = {}
+        @source_started = {}
+        @global_label_export = []
+        @called_subroutines = []
+        @default_capture_wave_name = 'default_capture_waveform'
+        @default_source_wave_name = 'default_source_waveform'
+      end
+
+      # Internal method called by Origen
+      def pattern_header(options = {})
+        microcode 'file_format_version 1.0;'
+        @global_label_export.each { |label| microcode "export #{label};" }
+        @called_subroutines.each { |sub| microcode "import #{sub};" }
+        called_timesets.each do |timeset|
+          microcode "timeset #{timeset.name};"
+        end
+        pin_list = ordered_pins.map(&:name).join(',')
+        microcode "pattern #{options[:pattern]} (#{pin_list})"
+        microcode '{'
+      end
+
+      # Internal method called by Origen
+      def pattern_footer(options = {})
+        # add capture/source stop to the end of the pattern
+        cycle microcode: 'capture_stop' if @capture_started[:default]
+        cycle microcode: 'halt'
+        microcode '}'
+      end
+
+      # Internal method called by Origen
+      def format_vector(vec)
+        timeset = vec.timeset ? " #{vec.timeset.name}" : ''
+        pin_vals = vec.pin_vals ? "#{vec.pin_vals} ;" : ''
+        microcode = vec.microcode ? vec.microcode : ''
+        if vec.repeat > 1
+          microcode = "repeat (#{vec.repeat})"
+        else
+          microcode = vec.microcode ? vec.microcode : ''
+        end
+        if vec.pin_vals && ($_testers_enable_vector_comments || vector_comments)
+          comment = " // #{vec.number}:#{vec.cycle} #{vec.inline_comment}"
+        else
+          comment = vec.inline_comment.empty? ? '' : " // #{vec.inline_comment}"
+        end
+
+        "#{microcode.ljust(65)}#{timeset.ljust(31)}#{pin_vals}#{comment}"
+      end
+
+      # insert a subroutine call
+      # provide optional argument to implement as jump instead of call:
+      #
+      # @example
+      #   tester.call_subroutine 'my_sub', jump: true
+      def call_subroutine(name, options = {})
+        options = { jump: false }.merge(options)
+        @called_subroutines << name.to_s.chomp unless @called_subroutines.include?(name.to_s.chomp)
+        local_microcode = ''
+        if options[:jump]
+          local_microcode = "jump #{name}"
+        else
+          local_microcode = "call #{name}"
+        end
+        update_vector microcode: local_microcode, offset: options[:offset]
+      end
+
+      # store/capture the state of the provided pins
+      def store(*pins)
+        options = pins.last.is_a?(Hash) ? pins.pop : {}
+        options = { offset: 0 }.merge(options)
+        pins = pins.flatten.compact
+
+        fail 'For the PXIE6570 you must supply the pins to store/capture' if pins.empty?
+        add_capture_start pins, options
+
+        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
+          end
+        end
+
+        update_vector microcode: 'capture', offset: options[:offset]
+      end
+      alias_method :to_hram, :store
+      alias_method :capture, :store
+
+      def add_microcode_to_first_vec(statement)
+        # find the first vector
+        i = 0
+        i += 1 until stage.bank[i].is_a?(OrigenTesters::Vector)
+        first_vector = stage.bank[i]
+
+        if first_vector.has_microcode? || first_vector.repeat > 1
+          v = OrigenTesters::Vector.new
+          v.pin_vals = first_vector.pin_vals
+          v.timeset = first_vector.timeset
+          v.inline_comment = 'added line for opcode insert'
+          v.dont_compress = true
+          v.microcode = statement
+          stage.insert_from_start v, i
+
+          # decrement repeat count of previous first vector if > 1
+          first_vector.repeat -= 1 if first_vector.repeat > 1
+        else
+          first_vector.microcode = statement
+        end
+      end
+
+      def cycle(options = {})
+        # handle overlay if requested
+        overlay_options = options.key?(:overlay) ? options.delete(:overlay) : {}
+        cur_pin_state = nil
+        if overlay_options.key?(:pins)
+          overlay_options = { change_data: true }.merge(overlay_options)
+          unless @source_started[:default]
+            add_microcode_to_first_vec "source_start(#{@default_source_wave_name})"
+            @source_started[:default] = true
+          end
+
+          # ensure no unwanted repeats on the source line
+          options[:dont_compress] = true
+
+          if overlay_options[:change_data]
+            if options[:microcode].nil?
+              options[:microcode] = 'source'
+            else
+              options[:microcode] = options[:microcode] + ', source'
+            end
+            options[:microcode] = options[:microcode] + ", repeat (#{options[:repeat]})" unless options[:repeat].nil?
+            options.delete(:repeat)
+          end
+
+          # set pins to drive data
+          cur_pin_state = overlay_options[:pins].state.to_sym
+          overlay_options[:pins].drive_mem
+        end
+        super(options)
+        overlay_options[:pins].state = cur_pin_state if overlay_options.key?(:pins)
+      end
+
+      # internal method to avoid needless code duplication
+      def add_capture_start(pins, options = {})
+        unless @capture_started[:default]
+          # add the capture start opcode to the top of the pattern
+          add_microcode_to_first_vec "capture_start(#{@default_capture_wave_name})"
+          @capture_started[:default] = true
+        end
+      end
+
+      # store/capture the provided pins on the next cycle
+      def store_next_cycle(*pins)
+        options = pins.last.is_a?(Hash) ? pins.pop : {}
+        options = { offset: 0 }.merge(options)
+        pins = pins.flatten.compact
+
+        fail 'For the PXIE6570 you must supply the pins to store/capture' if pins.empty?
+        add_capture_start pins, options
+
+        pins.each { |pin| pin.save; pin.capture }
+        preset_next_vector(microcode: 'capture') do
+          pins.each(&:restore)
+        end
+      end
+      alias_method :store!, :store_next_cycle
+
+      # add a label to the output pattern
+      def label(name, global = false)
+        microcode name + ':'
+        @global_label_export << name if global
+      end
+
+      # change the capture state character
+      def format_pin_state(pin)
+        response = super(pin)
+        response.sub('C', 'V')
+      end
+    end
+  end
+  Pxie6570 = LabVIEWBasedTester::Pxie6570
+end

data/lib/origen_testers/memory_style.rb

@@ -1,77 +1,77 @@
-module OrigenTesters
-  class MemoryStyle
-    attr_reader :pin_id, :size, :bit_order, :format, :trigger, :mode, :data_type
-
-    def initialize
-      @pin_id = []
-      @size = []
-      @bit_order = []
-      @format = []
-      @trigger = []
-      @mode = []
-      @data_type = []
-    end
-
-    # Set memory style attributes for the given pin
-    #
-    # @example
-    #   mem.pin :tdi, size: 8, trigger: :auto
-    def pin(*pin_ids)
-      options = pin_ids.last.is_a?(Hash) ? pin_ids.pop : {}
-      pin_ids.each_index do |i|
-        if pin_ids[i].is_a?(Symbol)
-          pin_ids[i] = dut.pin(pin_ids[i]).name
-        else
-          pin_ids[i] = pin_ids[i].name
-        end
-      end
-      @pin_id << pin_ids
-      @size << options[:size]
-      @bit_order << options[:bit_order]
-      @format << options[:format]
-      @trigger << options[:trigger]
-      @mode << options[:mode]
-      @data_type << options[:data_type]
-    end
-
-    # Get the chronologically last setting for the given pin's attributes
-    #
-    # @example
-    #   mem.pin :tdi, size: 1
-    #   mem.pin :tdi, size: 2
-    #
-    #   my_local_attribute_hash = mem.accumulate_attributes(:tdi)
-    #   # my_local_attribute_hash now is
-    #   # {pin_id: :tdi, size: 2, bit_order: nil, format: nil, trigger: nil}
-    def accumulate_attributes(pin_id)
-      a = { pin_id: pin_id }
-      @pin_id.each_index do |i|
-        if @pin_id[i].include?(pin_id)
-          a[:size] = @size[i]
-          a[:bit_order] = @bit_order[i]
-          a[:format] = @format[i]
-          a[:trigger] = @trigger[i]
-          a[:mode] = @mode[i]
-          a[:data_type] = @data_type[i]
-        end
-      end
-      a
-    end
-
-    # Check to see if a given pin exists in this style container
-    def contains_pin?(pin_id)
-      contained_pins.include?(pin_id)
-    end
-
-    # Get an array of pins contained in this style container
-    def contained_pins
-      pins = []
-      @pin_id.each do |a|
-        a.each do |p|
-          pins << p
-        end
-      end
-      pins.uniq
-    end
-  end
-end
+module OrigenTesters
+  class MemoryStyle
+    attr_reader :pin_id, :size, :bit_order, :format, :trigger, :mode, :data_type
+
+    def initialize
+      @pin_id = []
+      @size = []
+      @bit_order = []
+      @format = []
+      @trigger = []
+      @mode = []
+      @data_type = []
+    end
+
+    # Set memory style attributes for the given pin
+    #
+    # @example
+    #   mem.pin :tdi, size: 8, trigger: :auto
+    def pin(*pin_ids)
+      options = pin_ids.last.is_a?(Hash) ? pin_ids.pop : {}
+      pin_ids.each_index do |i|
+        if pin_ids[i].is_a?(Symbol)
+          pin_ids[i] = dut.pin(pin_ids[i]).name
+        else
+          pin_ids[i] = pin_ids[i].name
+        end
+      end
+      @pin_id << pin_ids
+      @size << options[:size]
+      @bit_order << options[:bit_order]
+      @format << options[:format]
+      @trigger << options[:trigger]
+      @mode << options[:mode]
+      @data_type << options[:data_type]
+    end
+
+    # Get the chronologically last setting for the given pin's attributes
+    #
+    # @example
+    #   mem.pin :tdi, size: 1
+    #   mem.pin :tdi, size: 2
+    #
+    #   my_local_attribute_hash = mem.accumulate_attributes(:tdi)
+    #   # my_local_attribute_hash now is
+    #   # {pin_id: :tdi, size: 2, bit_order: nil, format: nil, trigger: nil}
+    def accumulate_attributes(pin_id)
+      a = { pin_id: pin_id }
+      @pin_id.each_index do |i|
+        if @pin_id[i].include?(pin_id)
+          a[:size] = @size[i]
+          a[:bit_order] = @bit_order[i]
+          a[:format] = @format[i]
+          a[:trigger] = @trigger[i]
+          a[:mode] = @mode[i]
+          a[:data_type] = @data_type[i]
+        end
+      end
+      a
+    end
+
+    # Check to see if a given pin exists in this style container
+    def contains_pin?(pin_id)
+      contained_pins.include?(pin_id)
+    end
+
+    # Get an array of pins contained in this style container
+    def contained_pins
+      pins = []
+      @pin_id.each do |a|
+        a.each do |p|
+          pins << p
+        end
+      end
+      pins.uniq
+    end
+  end
+end

data/lib/origen_testers/no_interface.rb

@@ -1,7 +1,7 @@
-module OrigenTesters
-  # Origen will instantiate this interface if the application doesn't define one,
-  # this allows test flows to be generated only
-  class NoInterface
-    include OrigenTesters::ProgramGenerators
-  end
-end
+module OrigenTesters
+  # Origen will instantiate this interface if the application doesn't define one,
+  # this allows test flows to be generated only
+  class NoInterface
+    include OrigenTesters::ProgramGenerators
+  end
+end

data/lib/origen_testers/origen_ext/application/runner.rb

@@ -1,25 +1,25 @@
-# This shim is temporary to help NXP transition to Origen from
-# our original internal version (RGen)
-if defined? RGen::ORIGENTRANSITION
-  require 'rgen/application/runner'
-else
-  require 'origen/application/runner'
-end
-module Origen
-  class Application
-    class Runner
-      alias_method :orig_launch, :launch
-      # Patch this to allow write: false to be given as an option when
-      # generating a test program. When supplied and set to false, the program
-      # output files will not be written and only a flow model will be generated.
-      def launch(options = {})
-        if options.key?(:write)
-          OrigenTesters::Interface.write = options[:write]
-        else
-          OrigenTesters::Interface.write = true
-        end
-        orig_launch(options)
-      end
-    end
-  end
-end
+# This shim is temporary to help NXP transition to Origen from
+# our original internal version (RGen)
+if defined? RGen::ORIGENTRANSITION
+  require 'rgen/application/runner'
+else
+  require 'origen/application/runner'
+end
+module Origen
+  class Application
+    class Runner
+      alias_method :orig_launch, :launch
+      # Patch this to allow write: false to be given as an option when
+      # generating a test program. When supplied and set to false, the program
+      # output files will not be written and only a flow model will be generated.
+      def launch(options = {})
+        if options.key?(:write)
+          OrigenTesters::Interface.write = options[:write]
+        else
+          OrigenTesters::Interface.write = true
+        end
+        orig_launch(options)
+      end
+    end
+  end
+end

data/lib/origen_testers/origen_ext/generator.rb

@@ -1,54 +1,54 @@
-# This shim is temporary to help NXP transition to Origen from
-# our original internal version (RGen)
-if defined? RGen::ORIGENTRANSITION
-  require 'rgen/generator'
-else
-  require 'origen/generator'
-end
-module Origen
-  class Generator
-    include Comparator
-
-    # Makes more sense for this plugin to own this method now
-    def generate_program(file, options)
-      Origen.file_handler.resolve_files(file, ignore_with_prefix: '_', default_dir: "#{Origen.root}/program") do |path|
-        Origen.file_handler.current_file = path
-        j = Job.new(path, options)
-        j.pattern = path
-        j.run
-      end
-      Origen.interface.write_files(options)
-      unless options[:quiet] || !Origen.interface.write?
-        if options[:referenced_pattern_list]
-          file = "#{Origen.root}/list/#{options[:referenced_pattern_list]}"
-        else
-          file = Origen.config.referenced_pattern_list
-        end
-        puts "Referenced pattern list written to: #{Pathname.new(file).relative_path_from(Pathname.pwd)}"
-        dir = Pathname.new(file).dirname
-        FileUtils.mkdir_p(dir) unless dir.exist?
-        File.open(file, 'w') do |f|
-          pats = Origen.interface.all_pattern_references.map do |name, refs|
-            refs[:main][:all] + refs[:main][:origen]
-          end.flatten.uniq.sort
-          unless pats.empty?
-            f.puts '# Main patterns'
-            pats.each { |p| f.puts p }
-            f.puts
-          end
-
-          pats = Origen.interface.all_pattern_references.map do |name, refs|
-            refs[:subroutine][:all] + refs[:subroutine][:origen]
-          end.flatten.uniq.sort
-          unless pats.empty?
-            f.puts '# Subroutine patterns'
-            pats.each { |p| f.puts p }
-          end
-        end
-        ref_file = File.join(Origen.file_handler.reference_directory, Pathname.new(file).basename)
-        check_for_changes(file, ref_file)
-      end
-      Origen.interface.on_program_completion(options)
-    end
-  end
-end
+# This shim is temporary to help NXP transition to Origen from
+# our original internal version (RGen)
+if defined? RGen::ORIGENTRANSITION
+  require 'rgen/generator'
+else
+  require 'origen/generator'
+end
+module Origen
+  class Generator
+    include Comparator
+
+    # Makes more sense for this plugin to own this method now
+    def generate_program(file, options)
+      Origen.file_handler.resolve_files(file, ignore_with_prefix: '_', default_dir: "#{Origen.root}/program") do |path|
+        Origen.file_handler.current_file = path
+        j = Job.new(path, options)
+        j.pattern = path
+        j.run
+      end
+      Origen.interface.write_files(options)
+      unless options[:quiet] || !Origen.interface.write?
+        if options[:referenced_pattern_list]
+          file = "#{Origen.root}/list/#{options[:referenced_pattern_list]}"
+        else
+          file = Origen.config.referenced_pattern_list
+        end
+        puts "Referenced pattern list written to: #{Pathname.new(file).relative_path_from(Pathname.pwd)}"
+        dir = Pathname.new(file).dirname
+        FileUtils.mkdir_p(dir) unless dir.exist?
+        File.open(file, 'w') do |f|
+          pats = Origen.interface.all_pattern_references.map do |name, refs|
+            refs[:main][:all] + refs[:main][:origen]
+          end.flatten.uniq.sort
+          unless pats.empty?
+            f.puts '# Main patterns'
+            pats.each { |p| f.puts p }
+            f.puts
+          end
+
+          pats = Origen.interface.all_pattern_references.map do |name, refs|
+            refs[:subroutine][:all] + refs[:subroutine][:origen]
+          end.flatten.uniq.sort
+          unless pats.empty?
+            f.puts '# Subroutine patterns'
+            pats.each { |p| f.puts p }
+          end
+        end
+        ref_file = File.join(Origen.file_handler.reference_directory, Pathname.new(file).basename)
+        check_for_changes(file, ref_file)
+      end
+      Origen.interface.on_program_completion(options)
+    end
+  end
+end