origen_link 0.1.0.pre0 → 0.1.0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: origen_link
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre0
+  version: 0.1.0
 platform: ruby
 authors:
 - Paul Derouen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-22 00:00:00.000000000 Z
+date: 2016-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.6
+        version: 0.7.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.6
+        version: 0.7.2
 - !ruby/object:Gem::Dependency
   name: origen_testers
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.6.1
 - !ruby/object:Gem::Dependency
   name: origen_jtag
   requirement: !ruby/object:Gem::Requirement
@@ -66,29 +66,43 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - paul.derouen@nxp.com
-executables: []
+executables:
+- start_link_server
 extensions: []
 extra_rdoc_files: []
 files:
+- bin/start_link_server
 - config/application.rb
 - config/boot.rb
 - config/commands.rb
 - config/version.rb
 - lib/origen_link.rb
-- lib/origen_link/includes_vector_based.rb
-- lib/origen_link/test/regression_tests.rb
-- lib/origen_link/test/test_dut.rb
-- lib/origen_link/test/test_dut_controller.rb
-- lib/origen_link/test/vector_based_redefs.rb
+- lib/origen_link/callback_handlers.rb
+- lib/origen_link/server/jtag.rb
+- lib/origen_link/server/pin.rb
+- lib/origen_link/server/sequencer.rb
+- lib/origen_link/server_com.rb
+- lib/origen_link/test/top_level.rb
+- lib/origen_link/test/top_level_controller.rb
+- lib/origen_link/test/vector_based.rb
 - lib/origen_link/vector_based.rb
-- lib/origen_link_server/LinkSequencer.rb
-- lib/origen_link_server/LinkTCPServer.rb
-- lib/origen_link_server/jtag_interface.rb
-- lib/origen_link_server/pin_interface.rb
-- lib/origen_link_server/test/test_Sequencer.rb
 - lib/tasks/origen_link.rake
 - pattern/example.rb
 - pattern/jtag_100_operations.rb
@@ -117,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.2
 signing_key: 
 specification_version: 4
 summary: Origen interface to a live DUT tester

data/lib/origen_link/test/regression_tests.rb

@@ -1,68 +0,0 @@
-require_relative '..\vector_based'
-require_relative 'vector_based_redefs'
-require 'test/unit'
-
-class DummyTset
-  attr_accessor :name
-
-  def initialize
-    @name = 'default'
-  end
-end
-
-class TestVectorBased < Test::Unit::TestCase
-  def test_stuff
-    timeset_sim_obj = DummyTset.new
-
-    test_obj = OrigenLink::VectorBased.new('localhost', 12_777)
-    # setup pinmap
-    test_obj.pinmap = 'tck, 5, tdo, 8, tms, 10, tdi, 15'
-    assert_equal('pin_assign:tck,5,tdo,8,tms,10,tdi,15', test_obj.message)
-
-    # setup pin order  ---- notice there's currently no error checking to see if pinmap and pinorder have the same pins !!!
-    test_obj.pinorder = 'tck,tdo, tdi, extal'
-    assert_equal('pin_patternorder:tck,tdo,tdi,extal', test_obj.message)
-
-    assert_equal(true, test_obj.link?)
-    assert_equal('OrigenLink::VectorBased', test_obj.to_s)
-
-    test_obj.message = ''
-    test_obj.push_vector(timeset: timeset_sim_obj, pin_vals: '1100')
-    # check that pin values are being accumulated and not sent
-    assert_equal('', test_obj.message)
-    assert_equal(1, test_obj.vector_repeatcount)
-
-    # check that different vector data causes previous to be sent
-    test_obj.microcodestr = ''
-    test_obj.test_response = 'P:1100'
-    test_obj.push_vector(timeset: timeset_sim_obj, pin_vals: '1000')
-    assert_equal('pin_cycle:1100', test_obj.message)
-    assert_equal('P:1100', test_obj.microcodestr)
-
-    # check that repeat count accumulates
-    test_obj.microcodestr = ''
-    test_obj.push_vector(timeset: timeset_sim_obj, pin_vals: '1000')
-    assert_equal(2, test_obj.vector_repeatcount)
-
-    # check that repeat count is correctly sent
-    test_obj.test_response = 'P:repeat2,1000'
-    test_obj.flush_vector
-    assert_equal('pin_cycle:repeat2,1000', test_obj.message)
-
-    # check pin format setup
-    test_obj.test_response = 'P:'
-    test_obj.pinformat = 'func_25mhz, tck, rl'
-    assert_equal('pin_format:1,tck,rl', test_obj.message)
-
-    # check timing setup
-    test_obj.pintiming = 'func_25mhz, tdi, 0, tdo, 1, tms, 0'
-    assert_equal('pin_timing:1,tdi,0,tdo,1,tms,0', test_obj.message)
-
-    # check pin_cycle works correctly with tsets programmed
-    test_obj.test_response = 'P:tset0,1000'
-    timeset_sim_obj.name = 'func_25mhz'
-    test_obj.push_vector(timeset: timeset_sim_obj, pin_vals: '1000')
-    test_obj.flush_vector
-    assert_equal('pin_cycle:tset1,1000', test_obj.message)
-  end
-end

data/lib/origen_link/test/test_dut.rb

@@ -1,46 +0,0 @@
-module TestDut
-  class TopLevel
-    include Origen::TopLevel
-
-    def initialize(options = {})
-      instantiate_pins(options)
-      instantiate_registers(options)
-      instantiate_sub_blocks(options)
-    end
-
-    def instantiate_pins(options = {})
-      options = {
-        jtag_comm_config:			     false,
-        invalid_pin_number_test:	false,
-        missing_pinmap_test:		   false
-      }.merge(options)
-      add_pin :tclk
-      add_pin :tdi
-      add_pin :tdo
-      add_pin :tms
-      add_pin :resetb
-      add_pins :port_a, size: 8
-
-      pin_pattern_order :tclk, :tms, :tdi, :tdo, only: true if options[:jtag_comm_config]
-
-      # if tester.link? #.to_s == 'OrigenLink::VectorBased'
-      if tester.to_s == 'OrigenLink::VectorBased'
-        if options[:invalid_pin_number_test]
-          tester.pinmap = 'tclk,119,tms,1900,tdi,116,tdo,124'
-        else
-          tester.pinmap = 'tclk,119,tms,6,tdi,116,tdo,124' unless options[:missing_pinmap_test]
-        end
-        tester.pinorder = 'tclk,tms,tdi,tdo'
-      end
-    end
-
-    def instantiate_registers(options = {})
-      reg :testreg, 0 do |reg|
-        reg.bits 31..0,		:value
-      end
-    end
-
-    def instantiate_sub_blocks(options = {})
-    end
-  end
-end

data/lib/origen_link/test/test_dut_controller.rb

@@ -1,42 +0,0 @@
-module TestDut
-  class TopLevelController
-    include Origen::Controller
-
-    include OrigenJTAG
-
-    JTAG_CONFIG = {
-      #:tclk_format => :rl,
-      tclk_format:     :rh,
-      #:tclk_multiple => 1,
-      tclk_multiple:   4,
-      tdo_strobe:      :tclk_high,
-      tdo_store_cycle: 3,
-      init_state:      :idle
-    }
-
-    def startup(options)
-      pp 'Enter test mode' do
-        # if tester.link?
-        if tester.to_s == 'OrigenLink::VectorBased'
-          tester.initialize_pattern
-          # below is for testing return format timing, requires tclk to be rl and multiple of 1
-          # tester.pinformat = 'func_25mhz,tclk,rl'
-          # tester.pintiming = 'func_25mhz,tdi,0,tms,0,tdo,1'
-        end
-        tester.set_timeset('func_25mhz', 40)   # Where 40 is the period in ns
-        tester.wait time_in_us: 100
-      end
-    end
-
-    def shutdown(options)
-      pp 'Reset the device' do
-        pin(:resetb).drive!(0)
-        pin(:tclk).drive!(0)
-      end
-      # if tester.link?
-      if tester.to_s == 'OrigenLink::VectorBased'
-        tester.finalize_pattern
-      end
-    end
-  end
-end

data/lib/origen_link/test/vector_based_redefs.rb

@@ -1,17 +0,0 @@
-module OrigenLink
-  class VectorBased
-    attr_accessor :message, :microcodestr, :test_response
-
-    def send_cmd(cmdstr, argstr)
-      @message = cmdstr + ':' + argstr
-      @test_response
-    end
-
-    def setup_cmd_response_logger(command, response)
-    end
-
-    def microcode(msg)
-      @microcodestr = @microcodestr + msg
-    end
-  end
-end

data/lib/origen_link_server/LinkSequencer.rb

@@ -1,333 +0,0 @@
-# rubocop:disable Style/FileName: Use snake_case for source file names
-require_relative 'pin_interface'
-
-##################################################
-# OrigenLinkSequencer Class
-#    Instance variables:
-#      pinmap: hash with ["pin name"] = pin object
-#      patternpinindex: hash with ["pin name"] =
-#        integer index into vector data
-#      patternpinorder: Array with pin names in
-#        the vector order
-#
-#    This class processes messages targeted for
-#    pin sequencer interface (vector pattern
-#    execution).
-#
-#    Supported messages:
-#      pin_assign (create pin mapping)
-#        ex: "pin_assign:tck,3,extal,23,tdo,5"
-#
-#      pin_patternorder (define vector pin order)
-#        ex: "pin_patternorder:tdo,extal,tck"
-#
-#      pin_cycle (execute vector data)
-#        ex: "pin_cycle:H11"
-#
-#      pin_clear (clear all setup information)
-#        ex: "pin_clear:"
-#
-#      pin_format (setup a pin with return format)
-#        first argument is the timeset
-#        ex: "pin_format:1,tck,rl"
-#
-#      pin_timing (define when pin events happen)
-#        timing is stored in a timeset hash
-#        first argument is the timeset key
-#        ex: "pin_timing:1,tdi,0,tdo,1,tms,0
-##################################################
-class OrigenLinkSequencer
-  attr_reader :pinmap
-  attr_reader :patternorder
-  attr_reader :cycletiming
-  attr_reader :patternpinindex
-
-  ##################################################
-  # initialize method
-  #    Create empty pinmap, pattern pin index
-  #    and pattern order instance variables
-  ##################################################
-  def initialize
-    @pinmap = Hash.new(-1)
-    @patternpinindex = Hash.new(-1)
-    @patternorder = []
-    @cycletiming = Hash.new(-1)
-  end
-
-  ##################################################
-  # processmessage method
-  #    arguments: message
-  #      message format is <group>_<command>:<args>
-  #    returns: message response
-  #
-  #    This method splits a message into it's
-  #    command and arguments and passes this
-  #    information to the method that performs
-  #    the requested command
-  ##################################################
-  def processmessage(message)
-    command = message.split(':')
-
-    case command[0]
-    when 'pin_assign'
-      pin_assign(command[1])
-    when 'pin_patternorder'
-      pin_patternorder(command[1])
-    when 'pin_cycle'
-      pin_cycle(command[1])
-    when 'pin_clear'
-      pin_clear
-    when 'pin_format'
-      pin_format(command[1])
-    when 'pin_timing'
-      pin_timing(command[1])
-    else
-      'Error Invalid command: ' + command[0].to_s
-    end
-  end
-
-  ##################################################
-  # pin_assign method
-  #    arguments: <args> from the message request
-  #      see "processmessage" method
-  #    returns: "P:" or error message
-  #
-  #    This method creates a pin instance for each
-  #    pin in the pin map and builds the pinmap
-  #    hash.  Before the pinmap is created, any
-  #    information from a previous pattern run is
-  #    cleared.
-  ##################################################
-  def pin_assign(args)
-    pin_clear
-    success = true
-    fail_message = ''
-    argarr = args.split(',')
-    0.step(argarr.length - 2, 2) do |index|
-      @pinmap[argarr[index]] = OrigenLinkPin.new(argarr[index + 1])
-      unless @pinmap[argarr[index]].gpio_valid
-        success = false
-        fail_message = fail_message + 'pin ' + argarr[index] + ' gpio' + argarr[index + 1] + ' is invalid'
-      end
-    end
-    if success
-      'P:'
-    else
-      'F:' + fail_message
-    end
-  end
-
-  ##################################################
-  # new_timeset(tset)
-  #   creates a new empty timeset hash
-  ##################################################
-  def new_timeset(tset)
-    @cycletiming[tset] = {}
-    @cycletiming[tset]['timing'] = [[], [], []]
-  end
-
-  ##################################################
-  # pin_format method
-  #   arguments: <args> from the message request
-  #     Should be <timeset>,<pin>,rl or rh
-  #     multi-clock not currently supported
-  #
-  ##################################################
-  def pin_format(args)
-    argarr = args.split(',')
-    tset_key = argarr.delete_at(0).to_i
-    new_timeset(tset_key) unless @cycletiming.key?(tset_key)
-    @cycletiming[tset_key].delete('rl')
-    @cycletiming[tset_key].delete('rh')
-    0.step(argarr.length - 2, 2) do |index|
-      @cycletiming[tset_key][argarr[index + 1]] = [] unless @cycletiming[tset_key].key?(argarr[index + 1])
-      @cycletiming[tset_key][argarr[index + 1]] << argarr[index]
-    end
-    'P:'
-  end
-
-  ##################################################
-  # pin_timing method
-  #   arguments: <args> from the message request
-  #     Should be '1,pin,-1,pin2,0,pin3,1'
-  #     First integer is timeset number
-  #     If argument is '', default timing is created
-  #     Default timeset number is 0, this is used
-  #     if no timeset is explicitly defined
-  #
-  #     cycle arg:  0   1   2
-  #     waveform : ___/***\___
-  #
-  #   returns "P:" or error message
-  #
-  #   This method sets up a time set.  All retrun
-  #   format pins are driven between 0 and 1 and
-  #   return between 1 and 2.  Non-return pins are
-  #   acted upon during the 0, 1 or 2 time period.
-  ##################################################
-  def pin_timing(args)
-    argarr = args.split(',')
-    tset_key = argarr.delete_at(0).to_i
-    new_timeset(tset_key) unless @cycletiming.key?(tset_key)
-    @cycletiming[tset_key]['timing'].each do |index|
-      index.delete_if { true }
-    end
-    0.step(argarr.length - 2, 2) do |index|
-      @cycletiming[tset_key]['timing'][argarr[index + 1].to_i] << argarr[index]
-    end
-    'P:'
-  end
-
-  ##################################################
-  # pin_patternorder method
-  #    arguments: <args> from the message request
-  #    returns: "P:" or error message
-  #
-  #    This method is used to define the order
-  #    for pin vector data.
-  ##################################################
-  def pin_patternorder(args)
-    argarr = args.split(',')
-    index = 0
-    if @cycletiming.key?(0)
-      @cycletiming[0]['timing'][0].delete_if { true }
-    else
-      new_timeset(0)
-    end
-    argarr.each do |pin|
-      @patternorder << pin
-      @patternpinindex[pin] = index
-      @cycletiming[0]['timing'][0] << pin
-      index += 1
-    end
-    'P:'
-  end
-
-  ##################################################
-  # pin_cycle method
-  #    arguments: <args> from the message request
-  #    returns: "P:" or "F:" followed by results
-  #
-  #    This method executes one cycle of pin vector
-  #    data.  The vector data is decomposed and
-  #    sequenced.  Each pin object and pin data
-  #    is passed to the "process_pindata" method
-  #    for decoding and execution
-  ##################################################
-  def pin_cycle(args)
-    # set default repeats and timeset
-    repeat_count = 1
-    tset = 0
-    if args =~ /,/
-      parsedargs = args.split(',')
-      args = parsedargs.pop
-      parsedargs.each do |arg|
-        if arg =~ /repeat/
-          repeat_count = arg.sub(/repeat/, '').to_i
-        elsif arg =~ /tset/
-          tset = arg.sub(/tset/, '').to_i
-        end
-      end
-    end
-
-    message = ''
-    pindata = args.split('')
-    @cycle_failure = false
-    0.upto(repeat_count - 1) do |count|
-      response = {}
-      # process time 0 events
-      response = process_events(@cycletiming[tset]['timing'][0], pindata)
-      # send drive data for return format pins
-      response = (process_events(@cycletiming[tset]['rl'], pindata)).merge(response)
-      response = (process_events(@cycletiming[tset]['rh'], pindata)).merge(response)
-      # process time 1 events
-      response = process_events(@cycletiming[tset]['timing'][1], pindata).merge(response)
-      # send return data
-      unless @cycletiming[tset]['rl'].nil?
-        @cycletiming[tset]['rl'].each do |pin|
-          process_pindata(@pinmap[pin], '0')
-        end
-      end
-      unless @cycletiming[tset]['rh'].nil?
-        @cycletiming[tset]['rh'].each do |pin|
-          process_pindata(@pinmap[pin], '1')
-        end
-      end
-      # process time 2 events
-      response = process_events(@cycletiming[tset]['timing'][2], pindata).merge(response)
-      if (count == 0) || (@cycle_failure)
-        message = ''
-        @patternorder.each do |pin|
-          message += response[pin]
-        end
-      end
-    end # end cycle through repeats
-    if @cycle_failure
-      rtnmsg = 'F:' + message + '    Expected:' + args
-    else
-      rtnmsg = 'P:' + message
-    end
-    rtnmsg += '    Repeat ' + repeat_count.to_s if repeat_count > 1
-    rtnmsg
-  end
-
-  ##################################################
-  # process_events
-  #   used by pin_cycle to avoid duplicating code
-  ##################################################
-  def process_events(events, pindata)
-    response = {}
-    unless events.nil?
-      events.each do |pin|
-        response[pin] = process_pindata(@pinmap[pin], pindata[@patternpinindex[pin]])
-      end
-    end
-    response
-  end
-
-  ##################################################
-  # process_pindata method
-  #    arguments:
-  #      pin: the pin object to be operated on
-  #      data: the pin data to be executed
-  #    returns: the drive data or read data
-  #
-  #    This method translates pin data into one
-  #    of three possible events.  Drive 0, drive 1
-  #    or read.  Supported character decode:
-  #      drive 0: '0'
-  #      drive 1: '1'
-  #      read: anything else
-  ##################################################
-  def process_pindata(pin, data)
-    if data == '0' || data == '1'
-      pin.out(data)
-      data
-    else
-      case pin.in
-      when '0'
-        @cycle_failure = true if data == 'H'
-        'L'
-      when '1'
-        @cycle_failure = true if data == 'L'
-        'H'
-      else
-        'W'
-      end
-    end
-  end
-
-  ##################################################
-  # pin_clear method
-  #
-  #    This method clears all storage objects.  It
-  #    is called by the "pin_assign" method
-  ##################################################
-  def pin_clear
-    @pinmap.clear
-    @patternpinindex.clear
-    @patternorder.delete_if { true }
-    @cycletiming.clear
-    'P:'
-  end
-end