HDLRuby 2.0.8

data/lib/HDLRuby/high_samples/bugs/sample_sub.rb

@@ -0,0 +1,14 @@
+require 'HDLRuby'
+configure_high
+
+system :sub do
+
+	[15..0].input :ina,:inb
+	[16..0].output :result
+	
+	result <= ina - inb
+end
+
+sub :subI
+
+puts subI.to_low.to_yaml

data/lib/HDLRuby/high_samples/bugs/z2.rb

@@ -0,0 +1,32 @@
+require 'HDLRuby'
+configure_high
+
+system :z2 do
+
+	input :clk,:reset
+	signed[31..0].input :k1,:k2
+	signed[31..0].input :w2_1,:w2_2
+	signed[31..0].input :b2
+	signed[7..0].output :z2
+
+	signed[63..0].inner :net1,:net2
+	signed[31..0].inner :z2_tmp
+	
+	par(clk.posedge)do
+		hif(reset==1)do	
+			net1<=0
+			net2<=0
+			z2_tmp<=0
+		end
+		helse do
+			net1<=k1*w2_1
+			net2<=k2*w2_2
+			z2_tmp<=net1[55..24]+net2[55..24] + b2
+		end
+	end
+	
+	z2<=z2_tmp[27..20]
+end
+z2 :z2I
+
+puts z2I.to_low.to_yaml		

data/lib/HDLRuby/high_samples/case.rb

@@ -0,0 +1,32 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple decoder for testing the case statement.
+system :decoder do
+    [3..0].input :x
+    [7..0].output :s
+
+    par do
+        hcase(x)
+        hwhen(0) { s <= 1 }
+        hwhen(1) { s <= 2 }
+        hwhen(2) { s <= 4 }
+        hwhen(3) { s <= 8 }
+        hwhen(4) { s <= 16 }
+        hwhen(5) { s <= 32 }
+        hwhen(6) { s <= 64 }
+        hwhen(7) { s <= 128 }
+        helse    { s <= 0 }
+    end
+end
+
+# Instantiate it for checking.
+decoder :decoderI
+
+# Generate the low level representation.
+low = decoderI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/case2.rb

@@ -0,0 +1,30 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple decoder for testing the case statement.
+system :decoder do
+    [3..0].input :x
+    [7..0].output :s
+
+    hcase(x)
+    hwhen(0) { s <= 1 }
+    hwhen(1) { s <= 2 }
+    hwhen(2) { s <= 4 }
+    hwhen(3) { s <= 8 }
+    hwhen(4) { s <= 16 }
+    hwhen(5) { s <= 32 }
+    hwhen(6) { s <= 64 }
+    hwhen(7) { s <= 128 }
+    helse    { s <= 0 }
+end
+
+# Instantiate it for checking.
+decoder :decoderI
+
+# Generate the low level representation.
+low = decoderI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/change.rb

@@ -0,0 +1,23 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple test for using signals as event.
+system :with_change do
+    [15..0].input :x,:y
+    [16..0].output :s
+
+    par x,y do
+        s <= x + y
+    end
+end
+
+# Instantiate it for checking.
+with_change :with_changeI
+
+# Generate the low level representation.
+low = with_changeI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/clocks.rb

@@ -0,0 +1,35 @@
+require 'HDLRuby'
+
+configure_high
+
+
+require 'HDLRuby/std/clocks'
+include HDLRuby::High::Std
+
+
+# A simple test of the event multiplication constructs
+system :with_clocks do
+    input :clk,:rst
+    output :sig0, :sig1
+
+    configure_clocks(rst)
+
+    par(clk.posedge * 2) do
+        hif(rst) { sig0 <= 0 }
+        helse { sig0 <= ~sig0 }
+    end
+
+    par(clk.posedge * 3) do
+        hif(rst) { sig1 <= 0 }
+        helse { sig1 <= ~sig1 }
+    end
+end
+
+# Instantiate it for checking.
+with_clocks :with_clocksI
+
+# Generate the low level representation.
+low = with_clocksI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/comparer.rb

@@ -0,0 +1,21 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple 16-bit comparer
+system :comparer do
+    [15..0].input :x,:y
+    output :s
+
+    s <= (x < y)
+end
+
+# Instantiate it for checking.
+comparer :comparerI
+
+# Generate the low level representation.
+low = comparerI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/conditionals.rb

@@ -0,0 +1,29 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A system for testing conditionals
+system :conditionals do
+    [15..0].input :x,:y
+    output :s
+
+    par do
+        hif x <= y do
+            s <= 0
+        end
+        helse do
+            s <= 1
+        end
+    end
+
+end
+
+# Instantiate it for checking.
+conditionals :conditionalsI
+
+# Generate the low level representation.
+low = conditionalsI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/dff.rb

@@ -0,0 +1,23 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple D-FF
+system :dff do
+    input :clk, :rst, :d
+    output :q, :qb
+
+    qb <= ~q
+
+    par(clk.posedge) { q <= d & ~rst }
+end
+
+# Instantiate it for checking.
+dff :dffI
+
+# Generate the low level representation.
+low = dffI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/each.rb

@@ -0,0 +1,28 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple test of using each on signals.
+system :with_each do
+    [15..0].input :x
+    [15..0].output :s
+    [15..0].inout :y
+
+    x.each.with_index do |b,i|
+        s[i] <= b
+    end
+
+    y.each_cons(2) do |b0,b1|
+        b0 <= b1
+    end
+end
+
+# Instantiate it for checking.
+with_each :with_eachI
+
+# Generate the low level representation.
+low = with_eachI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/exporter.rb

@@ -0,0 +1,42 @@
+require 'HDLRuby'
+
+configure_high
+
+# A simple D-FF
+system :dff do
+    input :clk, :rst, :d
+    output :q
+
+    par(clk.posedge) { q <= d & ~rst }
+end
+
+# A system wrapping a D-FF and exporting things.
+system :exporter do
+    input :d
+    inner :clk, :rst
+
+    dff(:dff0).(clk: clk, rst: rst, d: d)
+
+    # Comment one of the following to check that without export, they cannot
+    # be used in a system inheriting from exporter
+    export :clk, :rst , :dff0 
+end
+
+# A system inheriting from exporter
+system :importer, exporter do
+    input :clk0, :rst0
+    output :q
+
+    clk <= clk0
+    rst <= rst0
+    dff0.q <= q
+end
+
+# # Instantiate it for checking.
+importer :importerI
+
+# Generate the low level representation.
+low = importerI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/functions.rb

@@ -0,0 +1,60 @@
+require 'HDLRuby'
+
+configure_high
+
+
+def hello_out
+    puts "hello_out"
+end
+
+def hello_mix(u,v,w)
+    puts "hello_mix"
+    par do
+        inner :something
+        w <= u - v
+    end
+end
+
+function :hello_sub do |name|
+    inner :nothing
+    puts "hello_sub, #{name}"
+    1
+end
+
+# A system for testing functions
+system :functions do
+    [15..0].input :x,:y, :z
+    [15..0].output :a, :b, :c, :d
+
+    hello_out
+
+    def hello_in
+        puts "hello_in"
+        a <= x + y
+    end
+
+    function :hello_in_sub do
+        inner :nothing_really
+        puts "hello_in_sub"
+        d <= x - y
+    end
+
+    hello_in
+
+    hello_mix(x,y,b)
+
+    c <= hello_sub("John Doe")
+
+    hello_in_sub
+end
+
+hello_out
+
+# Instantiate it for checking.
+functions :functionsI
+
+# Generate the low level representation.
+low = functionsI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/if_seq.rb

@@ -0,0 +1,26 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A example of behavior with an if using a seq block
+system :if_seq do
+    [15..0].input :x,:y, :clk
+    [16..0].inner :w
+    [16..0].output :o
+
+    par(clk.posedge) do
+        hif x>100, seq do
+            w <= y
+        end
+    end
+end
+
+# Instantiate it for checking.
+if_seq :if_seqI
+
+# Generate the low level representation.
+low = if_seqI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/inherit_as_dff.rb

@@ -0,0 +1,32 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple D-FF
+system :dff do
+    input :clk, :rst, :d
+    output :q
+
+    inner :db
+
+    db <= ~d
+
+    par(clk.posedge) { q <= d & ~rst }
+end
+
+# A D-FF with inverted ouput inheriting from dff
+system :dff_full,dff do
+    output :qb
+
+    qb <= as(dff).db
+end
+
+# Instantiate it for checking.
+dff_full :dff_fullI
+
+# Generate the low level representation.
+low = dff_fullI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/inherit_dff.rb

@@ -0,0 +1,36 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple D-FF
+system :dff do
+    input :clk, :rst, :d
+    output :q
+
+    par(clk.posedge) { q <= d & ~rst }
+end
+
+# A D-FF with inverted ouput inheriting from dff
+system :dff_full,dff do
+    output :qb
+
+    qb <= ~q
+end
+
+# A D-FF with a secondary output
+system :dff_fullest, dff_full do
+    output :qq
+    qq <= q
+end
+
+# Instantiate it for checking.
+# dff_full :dff_fullI
+dff_fullest :dff_fullestI
+
+# Generate the low level representation.
+# low = dff_fullI.systemT.to_low
+low = dff_fullestI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/instance.rb

@@ -0,0 +1,37 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A simple 16-bit or
+system :or16 do
+    [15..0].input :x,:y
+    [16..0].output :s
+
+    s <= x | y
+end
+
+# A 32-bit or made of two 16-bit ones.
+system :or32 do
+    [31..0].input :x,:y
+    [32..0].output :s
+
+    or16 :or0
+
+    or0.x <= x[15..0]
+    or0.y <= y[15..0]
+    s[15..0] <= or0.s[15..0]
+
+    or16(:or1).(x[31..16],y[31..16])
+
+    s[31..16] <= or1.s[31..16]
+end
+
+# Instantiate it for checking.
+or32 :or32I
+
+# Generate the low level representation.
+low = or32I.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/memory.rb

@@ -0,0 +1,64 @@
+require 'HDLRuby'
+
+configure_high
+
+# Describes an 8-bit data 16-bit address memory.
+system :mem8_16 do
+    input :clk, :rwb
+    [15..0].input :addr
+    [7..0].inout :data
+
+    bit[7..0][2**16].inner :content
+    
+    par(clk.posedge) do
+        hif(rwb) { data <= content[addr] }
+        helse    { content[addr] <= data }
+    end
+end
+
+# Instantiate it for checking.
+mem8_16 :mem8_16I
+
+
+# Describes a 16-bit memory made of 8-bit memories.
+system :mem16_16 do
+    input :clk, :rwb
+    [15..0].input :addr
+    [15..0].inout :data
+
+    mem8_16(:memL).(clk: clk, rwb: rwb, addr: addr, data: data[7..0])
+    mem8_16(:memH).(clk: clk, rwb: rwb, addr: addr, data: data[15..8])
+end
+
+# Instantiate it for checking.
+mem16_16 :mem16_16I
+
+
+# Describes a 16-bit memory made of 8-bit memories the long way.
+system :mem16_16_long do
+    input :clk, :rwb
+    [15..0].input :addr
+    [15..0].inout :data
+
+    mem8_16 [:memL, :memH]
+
+    memL.clk  <= clk
+    memL.rwb  <= rwb
+    memL.addr <= addr
+    memL.data <= data[7..0]
+
+    memH.clk  <= clk
+    memH.rwb  <= rwb
+    memH.addr <= addr
+    memH.data <= data[15..8]
+end
+
+# Instantiate it for checking.
+mem16_16_long :mem16_16_longI
+
+# Generate the low level representation.
+# low = mem16_16I.to_low
+low = mem16_16_longI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/multi_file.rb

@@ -0,0 +1,27 @@
+require 'HDLRuby'
+
+configure_high
+
+# Tests the inclusion of other files.
+
+require "./adder.rb"
+
+
+# Two parallel adders
+system :adder16_2 do
+    [15..0].input :x0,:y0,:x1,:y1
+    [16..0].output :s0,:s1
+
+    adder(:adder0).(x0,y0,s0)
+    
+    adder(:adder1).(x1,y1,s1)
+end
+
+# Instantiate it for checking.
+adder16_2 :adder16_2I
+
+# Generate the low level representation.
+low = adder16_2I.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/overload.rb

@@ -0,0 +1,32 @@
+require 'HDLRuby'
+
+configure_high
+
+
+# A 16-bit type with overloaded addition (saturated addition).
+[15..0].typedef(:sat16)
+sat16.define_operator(:+) do |left,right|
+    [16..0].inner :res
+    seq do
+        res <= left.as([15..0]) + right
+        hif (res[16]) { res <= 0xFFFF }
+    end
+    res
+end
+
+# A simple 16-bit adder
+system :adder do
+    sat16.input :x,:y
+    [15..0].output :s
+
+    s <= x + y
+end
+
+# Instantiate it for checking.
+adder :adderI
+
+# Generate the low level representation.
+low = adderI.systemT.to_low
+
+# Displays it
+puts low.to_yaml

data/lib/HDLRuby/high_samples/paper_after.rb

@@ -0,0 +1,49 @@
+require 'HDLRuby'
+
+configure_high
+
+def after(number, clk = $clk, rst = $rst, &code)
+    if in_behavior? and cur_behavior.on_edge? then
+        counter = HDLRuby.uniq_name
+        counter = [Math::log2(number).to_i+1].inner counter
+        hif(rst) { counter <= 0 }
+        helsif(counter < number) do
+            counter <= counter + 1
+        end
+        # hif(counter >= number) { code.call }
+        hif(counter >= number) { instance_eval(&code) }
+    else
+        counter = HDLRuby.uniq_name
+        cur_system.open do
+            counter = [Math::log2(number).to_i+1].inner counter
+            par(clk.posedge,rst.posedge) do
+                hif(rst) { counter <= 0 }
+                helse { counter <= counter + 1 }
+            end
+        end
+        # hif(counter >= number) { code.call }
+        hif(counter >= number) { instance_eval(&code) }
+    end
+end
+
+
+system :test_after0 do
+    input :clk,:rst
+    inner :sig0, :sig1
+
+    after(10,clk,rst) { sig0 <= 1 }
+    helse             { sig0 <= 0 }
+
+    par(clk.posedge,rst.posedge) do
+        sig1 <= 0
+        after(20) { sig1 <= 1 }
+    end
+end
+
+
+test_after0 :test_after0I
+
+low  = test_after0I.systemT.to_low
+
+# Displays it
+puts low.to_yaml