origen_testers 0.13.1 → 0.13.2

data/pattern/nvm/j750/timing.rb

@@ -1,73 +1,73 @@
-# This pattern exercises the methods in the Origen::Tester::Timing module
-def gen_vectors
-  2.times do
-    $nvm.pin(:invoke).drive(0)
-    $tester.cycle
-    $nvm.pin(:invoke).drive(1)
-    $tester.cycle
-  end
-end
-Pattern.create do
-
-  ss 'Test ability to switch timesets'
-
-  cc 'These vectors should use timeset nvm_slow'
-  $tester.set_timeset('nvm_slow', 200)
-  gen_vectors
-  cc 'These vectors should use timeset nvm_fast'
-  $tester.set_timeset('nvm_fast', 40)
-  gen_vectors
-
-  ss 'Test ability to switch timesets within a block'
-  cc 'These vectors should use timeset nvm_slow'
-  $tester.set_timeset('nvm_slow', 200) do
-    gen_vectors
-  end
-  cc 'These vectors should use timeset nvm_fast'
-  gen_vectors
-
-  ss 'Test ability to call a set timeset block with no arguments'
-  cc 'These vectors should use timeset nvm_fast'
-  $tester.set_timeset(nil) do
-    gen_vectors
-  end
-  cc 'These vectors should use timeset nvm_fast'
-  gen_vectors
-
-  ss 'Test ability to call with a single array argument'
-  cc 'These vectors should use timeset nvm_slow'
-  $tester.set_timeset(['nvm_slow', 40]) do
-    gen_vectors
-  end
-  cc 'These vectors should use timeset nvm_fast'
-  gen_vectors
-  cc 'These vectors should use timeset nvm_fast'
-  $tester.set_timeset([]) do
-    gen_vectors
-  end
-  cc 'These vectors should use timeset nvm_fast'
-  gen_vectors
-
-  ss 'Test that delay calculations are based on the current timeset period'
-
-  cc 'This should wait for 5 cycles, 1000/200'
-  $tester.set_timeset('nvm_slow', 200)
-  $tester.wait(:time_in_ns => 1000)
-  cc 'This should wait for 25 cycles, 1000/40'
-  $tester.set_timeset('nvm_fast', 40)
-  $tester.wait(:time_in_ns => 1000)
-
-  ss 'Test the period counter'
-  cc 'This should generate a sequence with a clock pulse on the clk'
-  cc 'pin with period of 1 ms, and overall duration 10 ms'
-  $nvm.pin(:clk).drive(0)
-  $tester.count(:period_in_ms => 1, :duration_in_ms => 10) do
-    $nvm.pin(:clk).drive!(1)
-    $nvm.pin(:clk).drive(0)
-  end
-
-  ss 'Test that Fixnum.cycles works'
-  cc 'There should be 10 cycles here'
-  10.cycles
-
-end
+# This pattern exercises the methods in the Origen::Tester::Timing module
+def gen_vectors
+  2.times do
+    $nvm.pin(:invoke).drive(0)
+    $tester.cycle
+    $nvm.pin(:invoke).drive(1)
+    $tester.cycle
+  end
+end
+Pattern.create do
+
+  ss 'Test ability to switch timesets'
+
+  cc 'These vectors should use timeset nvm_slow'
+  $tester.set_timeset('nvm_slow', 200)
+  gen_vectors
+  cc 'These vectors should use timeset nvm_fast'
+  $tester.set_timeset('nvm_fast', 40)
+  gen_vectors
+
+  ss 'Test ability to switch timesets within a block'
+  cc 'These vectors should use timeset nvm_slow'
+  $tester.set_timeset('nvm_slow', 200) do
+    gen_vectors
+  end
+  cc 'These vectors should use timeset nvm_fast'
+  gen_vectors
+
+  ss 'Test ability to call a set timeset block with no arguments'
+  cc 'These vectors should use timeset nvm_fast'
+  $tester.set_timeset(nil) do
+    gen_vectors
+  end
+  cc 'These vectors should use timeset nvm_fast'
+  gen_vectors
+
+  ss 'Test ability to call with a single array argument'
+  cc 'These vectors should use timeset nvm_slow'
+  $tester.set_timeset(['nvm_slow', 40]) do
+    gen_vectors
+  end
+  cc 'These vectors should use timeset nvm_fast'
+  gen_vectors
+  cc 'These vectors should use timeset nvm_fast'
+  $tester.set_timeset([]) do
+    gen_vectors
+  end
+  cc 'These vectors should use timeset nvm_fast'
+  gen_vectors
+
+  ss 'Test that delay calculations are based on the current timeset period'
+
+  cc 'This should wait for 5 cycles, 1000/200'
+  $tester.set_timeset('nvm_slow', 200)
+  $tester.wait(:time_in_ns => 1000)
+  cc 'This should wait for 25 cycles, 1000/40'
+  $tester.set_timeset('nvm_fast', 40)
+  $tester.wait(:time_in_ns => 1000)
+
+  ss 'Test the period counter'
+  cc 'This should generate a sequence with a clock pulse on the clk'
+  cc 'pin with period of 1 ms, and overall duration 10 ms'
+  $nvm.pin(:clk).drive(0)
+  $tester.count(:period_in_ms => 1, :duration_in_ms => 10) do
+    $nvm.pin(:clk).drive!(1)
+    $nvm.pin(:clk).drive(0)
+  end
+
+  ss 'Test that Fixnum.cycles works'
+  cc 'There should be 10 cycles here'
+  10.cycles
+
+end

data/pattern/read_write_reg.rb

@@ -1,61 +1,61 @@
-# Pattern to exercise the reading and writing of a register using ARM Debug
-Pattern.create do
-  ss 'Test write register with all 1s'
-  $dut.reg(:testme32).write!(0xFFFFFFFF)
-  ss 'Test read register after all 1s write'
-  $dut.reg(:testme32).read!
-
-  ss 'Test write register with all 0s'
-  $dut.reg(:testme32).write!(0x00000000)
-  ss 'Test read register after all 0s write'
-  $dut.reg(:testme32).read!
-
-  ss 'Test store register, the whole register data should be stored'
-  $dut.reg(:testme32).store!
-
-  ss 'Test store bits, only enable bit should be captured'
-  $dut.reg(:testme32).bit(:enable).store!
-
-  ss 'Test store bits, only port A should be captured'
-  $dut.reg(:testme32).bits(:portA).store!
-
-  ss 'Test read of partial register, only portA should be read'
-  $dut.reg(:testme32).bits(:portB).read!
-
-  ss 'Test overlay, all reg vectors should be from subroutine'
-  $dut.reg(:testme32).overlay('write_overlay')
-  $dut.reg(:testme32).write!
-
-  ss 'Test overlay, same again but for read'
-  $dut.reg(:testme32).overlay('read_overlay')
-  $dut.reg(:testme32).read!
-
-  ss 'Test bit level write overlay, only portA should be from subroutine'
-  $dut.reg(:testme32).overlay(nil)  # have to reset overlay bits as they are sticky from last overlay set
-  $dut.reg(:testme32).bits(:portA).overlay('write_overlay')
-  $dut.reg(:testme32).bits(:portA).write!
-
-  ss 'Test bit level read overlay, only portA should be from subroutine'
-  $dut.reg(:testme32).overlay(nil)
-  $dut.reg(:testme32).bits(:portA).overlay('read_overlay')
-  $dut.reg(:testme32).bits(:portA).read!
-
-  ss 'Call execute subroutine'
-  $dut.execute
-
-  ss 'Call match_pin subroutine'
-  $dut.match(:type => :match_pin)
-
-  ss 'Call match_2pins subroutine'
-  $dut.match(:type => :match_2pins)
-
-  ss 'Call match_2pins custom_jump subroutine'
-  $dut.match(:type => :match_2pins_custom_jump)
-
-  ss 'Call match_done subroutine'
-  $dut.match(:type => :match_done)
-
-  ss 'Call handshake subroutine'
-  $dut.handshake
-
-end
+# Pattern to exercise the reading and writing of a register using ARM Debug
+Pattern.create do
+  ss 'Test write register with all 1s'
+  $dut.reg(:testme32).write!(0xFFFFFFFF)
+  ss 'Test read register after all 1s write'
+  $dut.reg(:testme32).read!
+
+  ss 'Test write register with all 0s'
+  $dut.reg(:testme32).write!(0x00000000)
+  ss 'Test read register after all 0s write'
+  $dut.reg(:testme32).read!
+
+  ss 'Test store register, the whole register data should be stored'
+  $dut.reg(:testme32).store!
+
+  ss 'Test store bits, only enable bit should be captured'
+  $dut.reg(:testme32).bit(:enable).store!
+
+  ss 'Test store bits, only port A should be captured'
+  $dut.reg(:testme32).bits(:portA).store!
+
+  ss 'Test read of partial register, only portA should be read'
+  $dut.reg(:testme32).bits(:portB).read!
+
+  ss 'Test overlay, all reg vectors should be from subroutine'
+  $dut.reg(:testme32).overlay('write_overlay')
+  $dut.reg(:testme32).write!
+
+  ss 'Test overlay, same again but for read'
+  $dut.reg(:testme32).overlay('read_overlay')
+  $dut.reg(:testme32).read!
+
+  ss 'Test bit level write overlay, only portA should be from subroutine'
+  $dut.reg(:testme32).overlay(nil)  # have to reset overlay bits as they are sticky from last overlay set
+  $dut.reg(:testme32).bits(:portA).overlay('write_overlay')
+  $dut.reg(:testme32).bits(:portA).write!
+
+  ss 'Test bit level read overlay, only portA should be from subroutine'
+  $dut.reg(:testme32).overlay(nil)
+  $dut.reg(:testme32).bits(:portA).overlay('read_overlay')
+  $dut.reg(:testme32).bits(:portA).read!
+
+  ss 'Call execute subroutine'
+  $dut.execute
+
+  ss 'Call match_pin subroutine'
+  $dut.match(:type => :match_pin)
+
+  ss 'Call match_2pins subroutine'
+  $dut.match(:type => :match_2pins)
+
+  ss 'Call match_2pins custom_jump subroutine'
+  $dut.match(:type => :match_2pins_custom_jump)
+
+  ss 'Call match_done subroutine'
+  $dut.match(:type => :match_done)
+
+  ss 'Call handshake subroutine'
+  $dut.handshake
+
+end

data/pattern/reset.rb

@@ -1,4 +1,4 @@
-# Pattern to exercise the reading and writing of a register using Nexus
-Pattern.create do
-  $dut.reset
-end
+# Pattern to exercise the reading and writing of a register using Nexus
+Pattern.create do
+  $dut.reset
+end

data/pattern/subroutines.rb

@@ -1,69 +1,69 @@
-unless $tester.v93k?
-  # Pattern to define subroutines
-  if $tester.respond_to?('start_subroutine')
-    Pattern.create(:subroutine_pat => true) do
-
-      # Define execute subr
-      $dut.execute(:define => true)
-
-      # Define match_pin
-      $dut.match(:define => true, :type => :match_pin)
-
-      # Define match_2pins
-      $dut.match(:define => true, :type => :match_2pins)
-
-      # Define match_done subr
-      $dut.match(:define => true, :type => :match_done, :delay_in_us => 5)
-
-      # Define match_done subr with longer timeout of 7mS
-      $dut.match(:subr_name => 'match_done2', :define => true, :type => :match_done, :delay_in_us => 7000)
-
-      # Define match_done subr with longer timeout of 7sec
-      $dut.match(:subr_name => 'match_done3', :define => true, :type => :match_done, :delay_in_us => 7000000)
-
-      # Define match_done subr with longer timeout of 72sec
-      $dut.match(:subr_name => 'match_done4', :define => true, :type => :match_done, :delay_in_us => 72_000_000)
-
-      # Define match_done subr with longer timeout of 10min
-      $dut.match(:subr_name => 'match_done5', :define => true, :type => :match_done, :delay_in_us => 7_000_000_000)
-
-      # Define match loop with multiple entries
-      $dut.match(:subr_name => 'match_done6', :define => true, :type => :multiple_entries, :delay_in_us => 15_000_000)
-
-      # Define match loop with custom jump
-      $dut.match(:define => true, :type => :match_2pins_custom_jump)
-
-      # Define handshake subr
-      $dut.handshake(:define => true)
-
-      if $tester.ultraflex?
-        # Define digsrc_overlay_testme32 subr
-        $dut.digsrc_overlay(:subr_name => 'digsrc_overlay_testme32', :define => true, overlay_reg: :testme32)
-
-        # Define digsrc_overlay subr
-        $dut.digsrc_overlay(:subr_name => 'digsrc_overlay', :define => true, overlay_cycle_num: 64)
-
-        # test out UF keep_alive subroutine capability
-        $dut.keepalive(define: true)
-
-        # test out single module subroutine capability, integrated with other normal subroutines
-        # only for UltraFLEX
-        $dut.execute(define: true, name: 'overlaysub1', onemodsub: true )
-        $dut.execute(define: true, name: 'overlaysub2', onemodsub: true )
-        $dut.execute(define: true, name: 'overlaysub3', onemodsub: true )
-        $dut.execute(define: true, name: 'overlaysub4', onemodsub: true )
-      end 
-    end
-
-    if $tester.ultraflex?
-       # test out single module subroutine capability in standalone pattern
-       # only for UltraFLEX
-      Pattern.create(name: 'subroutines2', subroutine_pat: true) do
-        $dut.execute(define: true, name: 'overlaysub5', onemodsub: true )
-        $dut.execute(define: true, name: 'overlaysub6', onemodsub: true )
-        $dut.execute(define: true, name: 'overlaysub7', onemodsub: true )
-        $dut.execute(define: true, name: 'overlaysub4', onemodsub: true )
-      end
-    end
-  end
-end
+unless $tester.v93k?
+  # Pattern to define subroutines
+  if $tester.respond_to?('start_subroutine')
+    Pattern.create(:subroutine_pat => true) do
+
+      # Define execute subr
+      $dut.execute(:define => true)
+
+      # Define match_pin
+      $dut.match(:define => true, :type => :match_pin)
+
+      # Define match_2pins
+      $dut.match(:define => true, :type => :match_2pins)
+
+      # Define match_done subr
+      $dut.match(:define => true, :type => :match_done, :delay_in_us => 5)
+
+      # Define match_done subr with longer timeout of 7mS
+      $dut.match(:subr_name => 'match_done2', :define => true, :type => :match_done, :delay_in_us => 7000)
+
+      # Define match_done subr with longer timeout of 7sec
+      $dut.match(:subr_name => 'match_done3', :define => true, :type => :match_done, :delay_in_us => 7000000)
+
+      # Define match_done subr with longer timeout of 72sec
+      $dut.match(:subr_name => 'match_done4', :define => true, :type => :match_done, :delay_in_us => 72_000_000)
+
+      # Define match_done subr with longer timeout of 10min
+      $dut.match(:subr_name => 'match_done5', :define => true, :type => :match_done, :delay_in_us => 7_000_000_000)
+
+      # Define match loop with multiple entries
+      $dut.match(:subr_name => 'match_done6', :define => true, :type => :multiple_entries, :delay_in_us => 15_000_000)
+
+      # Define match loop with custom jump
+      $dut.match(:define => true, :type => :match_2pins_custom_jump)
+
+      # Define handshake subr
+      $dut.handshake(:define => true)
+
+      if $tester.ultraflex?
+        # Define digsrc_overlay_testme32 subr
+        $dut.digsrc_overlay(:subr_name => 'digsrc_overlay_testme32', :define => true, overlay_reg: :testme32)
+
+        # Define digsrc_overlay subr
+        $dut.digsrc_overlay(:subr_name => 'digsrc_overlay', :define => true, overlay_cycle_num: 64)
+
+        # test out UF keep_alive subroutine capability
+        $dut.keepalive(define: true)
+
+        # test out single module subroutine capability, integrated with other normal subroutines
+        # only for UltraFLEX
+        $dut.execute(define: true, name: 'overlaysub1', onemodsub: true )
+        $dut.execute(define: true, name: 'overlaysub2', onemodsub: true )
+        $dut.execute(define: true, name: 'overlaysub3', onemodsub: true )
+        $dut.execute(define: true, name: 'overlaysub4', onemodsub: true )
+      end 
+    end
+
+    if $tester.ultraflex?
+       # test out single module subroutine capability in standalone pattern
+       # only for UltraFLEX
+      Pattern.create(name: 'subroutines2', subroutine_pat: true) do
+        $dut.execute(define: true, name: 'overlaysub5', onemodsub: true )
+        $dut.execute(define: true, name: 'overlaysub6', onemodsub: true )
+        $dut.execute(define: true, name: 'overlaysub7', onemodsub: true )
+        $dut.execute(define: true, name: 'overlaysub4', onemodsub: true )
+      end
+    end
+  end
+end

data/pattern/tester_overlay.rb

@@ -1,53 +1,62 @@
-Pattern.create(name: "test_overlay") do
-  tester.overlay_style = :digsrc
-  # increase coverage by changing tdi dig src settings
-  tester.source_memory :digsrc do |mem| 
-    mem.pin :tdi, size: 32
-  end
-  cc 'should get a repeat count added to this vector for digsrc start minimum distance'
-  tester.cycle
-  
-  dut.pin(:tclk).drive(1)
-  dut.pin(:tdi).drive(1)
-  dut.pin(:tdo).assert(1)
-  dut.pin(:tms).drive(1)
-  
-  cc 'should get a repeat 5 vector'
-  tester.cycle repeat: 5
-  
-  cc 'should get a send microcode and 1 cycle with D'
-  tester.cycle overlay: {overlay_str: 'dummy_str', pins: dut.pin(:tdi_a)}
-  cc 'should get a cycle with D and no send'
-  tester.cycle overlay: {overlay_str: 'dummy_str', pins: dut.pin(:tdi_a), change_data: false}
-  cc 'regular cycle with no D or send'
-  tester.cycle
-  
-  cc 'cycle with 001 on pa'
-  dut.pin(:pa).drive!(1)
-  cc 'send microcode followed by DDD on pa'
-  dut.pin(:pa).drive(0)
-  tester.cycle overlay: {overlay_str: "dummy_str", pins: dut.pin(:pa)}
-  cc 'cycle with 001 on pa'
-  dut.pin(:pa).drive!(1)
-  cc 'send microcode, DDD on pa with repeat 5 (will send 5 sets of data)'
-  dut.pin(:pa).drive(0)
-  tester.cycle repeat: 5, overlay: {overlay_str: "dummy_str", pins: dut.pin(:pa)}
-  cc 'cycle with 001 on pa'
-  dut.pin(:pa).drive!(1)
-  
-  # Now kick the tires of subroutine based overlay
-  # No vectors with the comment "// overlay deletes" should be kept
-  tester.overlay_style = :subroutine
-  dut.pin(:pa).drive(7)
-  tester.cycle inline_comment: 'overlay keeps'
-  tester.cycle inline_comment: 'overlay deletes', overlay: {overlay_str: "subr_test", pins: dut.pin(:tdi)}
-
-  # Now kick the tires of label overlay
-  tester.cycle repeat: 20
-  tester.overlay_style = :label
-  dut.pin(:pa).drive(5)
-  tester.cycle inline_comment: '1st line after global label for overlay', overlay: {overlay_str: 'label_test', pins: dut.pin(:pa)}
-  tester.cycle inline_comment: '2nd line after global label for overlay', overlay: {overlay_str: 'label_test', pins: dut.pin(:pa)}
-  tester.cycle inline_comment: '3rd line after global label for overlay', overlay: {overlay_str: 'label_test', pins: dut.pin(:pa)}
-  tester.cycle repeat: 20
+Pattern.create(name: "test_overlay") do
+  tester.overlay_style = :digsrc
+  # increase coverage by changing tdi dig src settings
+  tester.source_memory :digsrc do |mem| 
+    mem.pin :tdi, size: 32
+  end
+  cc 'should get a repeat count added to this vector for digsrc start minimum distance'
+  tester.cycle
+  
+  dut.pin(:tclk).drive(1)
+  dut.pin(:tdi).drive(1)
+  dut.pin(:tdo).assert(1)
+  dut.pin(:tms).drive(1)
+  
+  cc 'should get a repeat 5 vector'
+  tester.cycle repeat: 5
+  
+  cc 'should get a send microcode and 1 cycle with D'
+  tester.cycle overlay: {overlay_str: 'dummy_str', pins: dut.pin(:tdi_a)}
+  cc 'should get a cycle with D and no send'
+  tester.cycle overlay: {overlay_str: 'dummy_str', pins: dut.pin(:tdi_a), change_data: false}
+  cc 'regular cycle with no D or send'
+  tester.cycle
+  
+  cc 'cycle with 001 on pa'
+  dut.pin(:pa).drive!(1)
+  cc 'send microcode followed by DDD on pa'
+  dut.pin(:pa).drive(0)
+  tester.cycle overlay: {overlay_str: "dummy_str", pins: dut.pin(:pa)}
+  cc 'cycle with 001 on pa'
+  dut.pin(:pa).drive!(1)
+  cc 'send microcode, DDD on pa with repeat 5 (will send 5 sets of data)'
+  dut.pin(:pa).drive(0)
+  tester.cycle repeat: 5, overlay: {overlay_str: "dummy_str", pins: dut.pin(:pa)}
+  cc 'cycle with 001 on pa'
+  dut.pin(:pa).drive!(1)
+  
+  # Now kick the tires of subroutine based overlay
+  # No vectors with the comment "// overlay deletes" should be kept
+  tester.overlay_style = :subroutine
+  dut.pin(:pa).drive(7)
+  tester.cycle inline_comment: 'overlay keeps'
+  tester.cycle inline_comment: 'overlay deletes', overlay: {overlay_str: "subr_test", pins: dut.pin(:tdi)}
+
+  # Now kick the tires of label overlay
+  tester.cycle repeat: 20
+  tester.overlay_style = :label
+  dut.pin(:pa).drive(5)
+  tester.cycle inline_comment: '1st line after local label for overlay', overlay: {overlay_str: 'label_test', pins: dut.pin(:pa)}
+  tester.cycle inline_comment: '2nd line after local label for overlay', overlay: {overlay_str: 'label_test', pins: dut.pin(:pa)}
+  tester.cycle inline_comment: '3rd line after local label for overlay', overlay: {overlay_str: 'label_test', pins: dut.pin(:pa)}
+  tester.cycle repeat: 20
+  
+  # Now kick the tires of global label overlay
+  tester.cycle repeat: 20
+  tester.overlay_style = :global_label
+  dut.pin(:pa).drive(5)
+  tester.cycle inline_comment: '1st line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
+  tester.cycle inline_comment: '2nd line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
+  tester.cycle inline_comment: '3rd line after global label for overlay', overlay: {overlay_str: 'global_label_test', pins: dut.pin(:pa)}
+  tester.cycle repeat: 20
 end