origen_testers 0.13.1 → 0.13.2

data/pattern/bitmap.rb

@@ -1,7 +1,7 @@
-# Pattern to exercise the keep alive of a pattern that needs reburst
-Pattern.create(end_in_ka: true) do
-
-  ss 'Dummy write reg'
-  $dut.reg(:testme32).write!(0xFFFFFFFF)
-  
-end
+# Pattern to exercise the keep alive of a pattern that needs reburst
+Pattern.create(end_in_ka: true) do
+
+  ss 'Dummy write reg'
+  $dut.reg(:testme32).write!(0xFFFFFFFF)
+  
+end

data/pattern/dc_instr.rb

@@ -1,7 +1,7 @@
-# Pattern to exercise the DC instrument test feature of tester
-
-Pattern.create() do
-  
-#  Execute standard soc method -- pins should magically get set with Pset if needed here 
-  
-end
+# Pattern to exercise the DC instrument test feature of tester
+
+Pattern.create() do
+  
+#  Execute standard soc method -- pins should magically get set with Pset if needed here 
+  
+end

data/pattern/delay.rb

@@ -1,7 +1,7 @@
-# Pattern to exercise a simple time delay
-
-Pattern.create() do
-  
- $tester.wait(:time_in_ms => 40) 
-  
-end
+# Pattern to exercise a simple time delay
+
+Pattern.create() do
+  
+ $tester.wait(:time_in_ms => 40) 
+  
+end

data/pattern/freq_counter.rb

@@ -1,6 +1,6 @@
-# Pattern to exercise the Freq Counter feature
-unless $tester.v93k?
-  Pattern.create do
-    $dut.freq_count
-  end
-end
+# Pattern to exercise the Freq Counter feature
+unless $tester.v93k?
+  Pattern.create do
+    $dut.freq_count
+  end
+end

data/pattern/mem_test.rb

@@ -1,8 +1,8 @@
-unless $tester.v93k?
-  # Pattern to exercise the memory test feature of tester
-  Pattern.create(:memory_test => true) do
-    
-    $dut.memory_test
-    
-  end
-end
+unless $tester.v93k?
+  # Pattern to exercise the memory test feature of tester
+  Pattern.create(:memory_test => true) do
+    
+    $dut.memory_test
+    
+  end
+end

data/pattern/multi_vector.rb

@@ -1,122 +1,122 @@
-class SetupTester
-  include Origen::PersistentCallbacks
-
-  def before_pattern(pattern_name)
-    case
-    when pattern_name =~ /^mm_single\./
-      $tester.vector_group_size = 1
-    when pattern_name =~ /^mm_dual\./
-      $tester.vector_group_size = 2
-    when pattern_name =~ /^mm_quad\./
-      $tester.vector_group_size = 4
-    else
-      # To avoid breaking later tests
-      $tester.vector_group_size = 1
-    end
-  end
-end
-SetupTester.new
-
-[:single, :dual, :quad].each do |size|
-  # Startup is being skipped here since it is currently a test of the ability
-  # to render (i.e. paste) vectors, therefore they are not compressible by
-  # Origen and which makes debugging this confusing!
-  Pattern.create(name: "mm_#{size}", skip_startup: true) do
-    $tester.set_timeset("nvmbist", 40)
-
-    ss "$tester.cycle(repeat: 128)"
-    $tester.cycle(repeat: 128)
-
-    ss do
-      cc "64.times do"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "end"
-    end
-    64.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-    end
-
-    ss do
-      cc "64.times do"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "end"
-    end
-    64.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-    end
-
-    ss do
-      cc "64.times do"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "end"
-    end
-    64.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-    end
-
-    ss do
-      cc "Test of period levelling"
-    end
-    $tester.timing_toggled_pins << $dut.pin(:tclk)
-    $dut.pin(:tdo).assert(0)
-    8.cycles
-    $tester.set_timeset("nvmbist_readout", 160)
-    8.cycles
-    ss "Test that additional stores are not injected, only 4 TDO vectors should be captured"
-    4.times do
-      1.cycle
-      $tester.store($dut.pin(:tdo))
-    end
-    $dut.pin(:tdo).dont_care
-    $tester.set_timeset("nvmbist", 40)
-
-    if $tester.vector_group_size == 1
-      ss do
-        cc "Test that these collapse to a single repeat in the single vector case"
-      end
-      $dut.pin(:tdi).drive(1)
-      $tester.wait cycles: 60000
-      $tester.cycle
-      $dut.pin(:tdi).dont_care
-    end
-
-    ss do
-      cc "Test that these collapse to correct multiple repeats"
-    end
-    $dut.pin(:tdi).drive(1)
-    $tester.wait cycles: 300000
-    $dut.pin(:tdi).dont_care
-
-    ss do
-      cc "Verify that comments at the end of the pattern work OK"
-    end
-    $dut.pin(:tdi).drive(0)
-    $tester.wait cycles: 1200
-    cc "This comment should appear after the delay 1200"
-
-    # Don't add anything new here, the above test should be last in this pattern
-
-  end
-end
+class SetupTester
+  include Origen::PersistentCallbacks
+
+  def before_pattern(pattern_name)
+    case
+    when pattern_name =~ /^mm_single\./
+      $tester.vector_group_size = 1
+    when pattern_name =~ /^mm_dual\./
+      $tester.vector_group_size = 2
+    when pattern_name =~ /^mm_quad\./
+      $tester.vector_group_size = 4
+    else
+      # To avoid breaking later tests
+      $tester.vector_group_size = 1
+    end
+  end
+end
+SetupTester.new
+
+[:single, :dual, :quad].each do |size|
+  # Startup is being skipped here since it is currently a test of the ability
+  # to render (i.e. paste) vectors, therefore they are not compressible by
+  # Origen and which makes debugging this confusing!
+  Pattern.create(name: "mm_#{size}", skip_startup: true) do
+    $tester.set_timeset("nvmbist", 40)
+
+    ss "$tester.cycle(repeat: 128)"
+    $tester.cycle(repeat: 128)
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "Test of period levelling"
+    end
+    $tester.timing_toggled_pins << $dut.pin(:tclk)
+    $dut.pin(:tdo).assert(0)
+    8.cycles
+    $tester.set_timeset("nvmbist_readout", 160)
+    8.cycles
+    ss "Test that additional stores are not injected, only 4 TDO vectors should be captured"
+    4.times do
+      1.cycle
+      $tester.store($dut.pin(:tdo))
+    end
+    $dut.pin(:tdo).dont_care
+    $tester.set_timeset("nvmbist", 40)
+
+    if $tester.vector_group_size == 1
+      ss do
+        cc "Test that these collapse to a single repeat in the single vector case"
+      end
+      $dut.pin(:tdi).drive(1)
+      $tester.wait cycles: 60000
+      $tester.cycle
+      $dut.pin(:tdi).dont_care
+    end
+
+    ss do
+      cc "Test that these collapse to correct multiple repeats"
+    end
+    $dut.pin(:tdi).drive(1)
+    $tester.wait cycles: 300000
+    $dut.pin(:tdi).dont_care
+
+    ss do
+      cc "Verify that comments at the end of the pattern work OK"
+    end
+    $dut.pin(:tdi).drive(0)
+    $tester.wait cycles: 1200
+    cc "This comment should appear after the delay 1200"
+
+    # Don't add anything new here, the above test should be last in this pattern
+
+  end
+end

data/pattern/multi_vector_plus1.rb

@@ -1,125 +1,125 @@
-# This pattern is to test that patterns pad correctly when they end on an
-# odd number of vectors.
-# Don't add things to the main body, modify multi_vector.rb instead.
-
-class SetupTester
-  include Origen::PersistentCallbacks
-
-  def before_pattern(pattern_name)
-    case
-    when pattern_name =~ /^mm_single_plus1\./
-      $tester.vector_group_size = 1
-    when pattern_name =~ /^mm_dual_plus1\./
-      $tester.vector_group_size = 2
-    when pattern_name =~ /^mm_quad_plus1\./
-      $tester.vector_group_size = 4
-    else
-      # To avoid breaking later tests
-      $tester.vector_group_size = 1
-    end
-  end
-end
-SetupTester.new
-
-[:single, :dual, :quad].each do |size|
-  # Startup is being skipped here since it is currently a test of the ability
-  # to render (i.e. paste) vectors, therefore they are not compressible by
-  # Origen and which makes debugging this confusing!
-  Pattern.create(name: "mm_#{size}_plus1", skip_startup: true) do
-    $tester.set_timeset("nvmbist", 40)
-
-    ss "$tester.cycle(repeat: 128)"
-    $tester.cycle(repeat: 128)
-
-    ss do
-      cc "64.times do"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "end"
-    end
-    64.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-    end
-
-    ss do
-      cc "64.times do"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "end"
-    end
-    64.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-    end
-
-    ss do
-      cc "64.times do"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(0)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "  $dut.pin(:tclk).drive!(1)"
-      cc "end"
-    end
-    64.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-      $dut.pin(:tclk).drive!(1)
-    end
-
-    ss do
-      cc "Test of period levelling"
-    end
-    8.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-    end
-    $tester.set_timeset("nvmbist_readout", 80)
-    8.times do
-      $dut.pin(:tclk).drive!(0)
-      $dut.pin(:tclk).drive!(1)
-    end
-    $tester.set_timeset("nvmbist", 40)
-
-    if $tester.vector_group_size == 1
-      ss do
-        cc "Test that these collapse to a single repeat in the single vector case"
-      end
-      $dut.pin(:tdi).drive(1)
-      $tester.wait cycles: 60000
-      $tester.cycle
-      $dut.pin(:tdi).dont_care
-    end
-
-    ss do
-      cc "Test that these collapse to correct multiple repeats"
-    end
-    $dut.pin(:tdi).drive(1)
-    $tester.wait cycles: 300000
-    $dut.pin(:tdi).dont_care
-
-    ss do
-      cc "Verify that comments at the end of the pattern work OK"
-    end
-    $dut.pin(:tdi).drive(0)
-    $tester.wait cycles: 1200
-    cc "This comment should appear after the delay 1200"
-    $tester.cycle
-
-    # Don't add anything new here, the above test should be last in this pattern
-
-  end
-end
+# This pattern is to test that patterns pad correctly when they end on an
+# odd number of vectors.
+# Don't add things to the main body, modify multi_vector.rb instead.
+
+class SetupTester
+  include Origen::PersistentCallbacks
+
+  def before_pattern(pattern_name)
+    case
+    when pattern_name =~ /^mm_single_plus1\./
+      $tester.vector_group_size = 1
+    when pattern_name =~ /^mm_dual_plus1\./
+      $tester.vector_group_size = 2
+    when pattern_name =~ /^mm_quad_plus1\./
+      $tester.vector_group_size = 4
+    else
+      # To avoid breaking later tests
+      $tester.vector_group_size = 1
+    end
+  end
+end
+SetupTester.new
+
+[:single, :dual, :quad].each do |size|
+  # Startup is being skipped here since it is currently a test of the ability
+  # to render (i.e. paste) vectors, therefore they are not compressible by
+  # Origen and which makes debugging this confusing!
+  Pattern.create(name: "mm_#{size}_plus1", skip_startup: true) do
+    $tester.set_timeset("nvmbist", 40)
+
+    ss "$tester.cycle(repeat: 128)"
+    $tester.cycle(repeat: 128)
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "64.times do"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(0)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "  $dut.pin(:tclk).drive!(1)"
+      cc "end"
+    end
+    64.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+      $dut.pin(:tclk).drive!(1)
+    end
+
+    ss do
+      cc "Test of period levelling"
+    end
+    8.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+    $tester.set_timeset("nvmbist_readout", 80)
+    8.times do
+      $dut.pin(:tclk).drive!(0)
+      $dut.pin(:tclk).drive!(1)
+    end
+    $tester.set_timeset("nvmbist", 40)
+
+    if $tester.vector_group_size == 1
+      ss do
+        cc "Test that these collapse to a single repeat in the single vector case"
+      end
+      $dut.pin(:tdi).drive(1)
+      $tester.wait cycles: 60000
+      $tester.cycle
+      $dut.pin(:tdi).dont_care
+    end
+
+    ss do
+      cc "Test that these collapse to correct multiple repeats"
+    end
+    $dut.pin(:tdi).drive(1)
+    $tester.wait cycles: 300000
+    $dut.pin(:tdi).dont_care
+
+    ss do
+      cc "Verify that comments at the end of the pattern work OK"
+    end
+    $dut.pin(:tdi).drive(0)
+    $tester.wait cycles: 1200
+    cc "This comment should appear after the delay 1200"
+    $tester.cycle
+
+    # Don't add anything new here, the above test should be last in this pattern
+
+  end
+end