def test_abs(self):
sys = py4hw.HWSystem()
fp = py4hw.FloatingPointHelper()
a = sys.wire('a', 32)
b = sys.wire('b', 32)
gt = sys.wire('gt')
eq= sys.wire('eq')
lt = sys.wire('lt')
py4hw.FPComparator_SP(sys, 'cmp', a, b, gt, eq, lt, absolute=True)
av = -971.0587159810018
bv = -353.1498041093273
a.put(fp.sp_to_ieee754(av))
b.put(fp.sp_to_ieee754(bv))
print('TESTING: ', av, bv, fp.zp_bin(fp.sp_to_ieee754(av), 32), fp.zp_bin(fp.sp_to_ieee754(bv), 32))
sys.getSimulator().clk(1)
assert(bool(gt.get()) == (abs(av) > abs(bv)))
assert(bool(eq.get()) == (abs(av) == abs(bv)))
assert(bool(lt.get()) == (abs(av) < abs(bv)))
def test_1(self):
sys = py4hw.HWSystem()
fp = py4hw.FloatingPointHelper()
a = sys.wire('a', 32)
b = sys.wire('b', 32)
gt = sys.wire('gt')
eq= sys.wire('eq')
lt = sys.wire('lt')
py4hw.FPComparator_SP(sys, 'cmp', a, b, gt, eq, lt)
av = 305.531528442573
bv = 443.5870680854455
a.put(fp.sp_to_ieee754(av))
b.put(fp.sp_to_ieee754(bv))
print('TESTING: ', av, bv, fp.zp_bin(fp.sp_to_ieee754(av), 32), fp.zp_bin(fp.sp_to_ieee754(bv), 32))
sys.getSimulator().clk(1)
assert(bool(gt.get()) == (av > bv))
assert(bool(eq.get()) == (av == bv))
assert(bool(lt.get()) == (av < bv))
def test_1(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
c = sys.wire("c", 32)
r1 = sys.wire("r1", 32)
r2 = sys.wire("r2", 32)
r3 = sys.wire("r3", 32)
py4hw.And2(sys, "and1", a, b, r1)
py4hw.And2(sys, "and2", a, c, r2)
py4hw.And2(sys, "and3", b, c, r3)
py4hw.Constant(sys, "a", 0xF, a)
py4hw.Constant(sys, "b", 0xA, b)
py4hw.Constant(sys, "c", 0x5, c)
py4hw.Scope(sys, "r1 (0xF & 0xA)", r1)
py4hw.Scope(sys, "r2 (0xF & 0x5)", r2)
py4hw.Scope(sys, "r3 (0xA & 0x5)", r3)
sys.getSimulator().clk(1)
assert (r1.get() == 10)
assert (r2.get() == 5)
assert (r3.get() == 0)
def test_random_abs(self):
import random
sys = py4hw.HWSystem()
fp = py4hw.FloatingPointHelper()
a = sys.wire('a', 32)
b = sys.wire('b', 32)
gt = sys.wire('gt')
eq= sys.wire('eq')
lt = sys.wire('lt')
py4hw.FPComparator_SP(sys, 'cmp', a, b, gt, eq, lt, absolute=True)
for i in range(100):
av = (random.random()-0.5) * 2000
bv = (random.random()-0.5) * 2000
a.put(fp.sp_to_ieee754(av))
b.put(fp.sp_to_ieee754(bv))
print('TESTING: ', av, bv)
sys.getSimulator().clk(1)
assert(bool(gt.get()) == (abs(av) > abs(bv)))
assert(bool(eq.get()) == (abs(av) == abs(bv)))
assert(bool(lt.get()) == (abs(av) < abs(bv)))
def test_1(self):
print('testing minterms equal to 5')
sys = py4hw.HWSystem()
r = sys.wire("r", 1)
a0 = sys.wire("a0", 1)
a1 = sys.wire("a1", 1)
a2 = sys.wire("a2", 1)
exp_a0 = [0, 1, 0, 1, 0, 1, 0, 1]
exp_a1 = [0, 0, 1, 1, 0, 0, 1, 1]
exp_a2 = [0, 0, 0, 0, 1, 1, 1, 1]
py4hw.Sequence(sys, "a0", exp_a0, a0)
py4hw.Sequence(sys, "a1", exp_a1, a1)
py4hw.Sequence(sys, "a2", exp_a2, a2)
py4hw.Minterm(sys, 'minterm', [a0, a1, a2], 5, r)
for i in range(8):
sys.getSimulator().clk(1)
rv = r.get()
a0v = a0.get()
a1v = a1.get()
a2v = a2.get()
print(a2v, a1v, a0v, rv)
assert (a0v == exp_a0[i])
assert (a1v == exp_a1[i])
assert (a2v == exp_a2[i])
def test_3(self):
# concatenating larger wires should raise an error
sys = py4hw.HWSystem()
a = sys.wire("a", 13)
b = sys.wire("b", 23)
c = sys.wire("c", 11)
r = sys.wire("r", 32)
av = 11
bv = 23
cv = 111
try:
py4hw.ConcatenateMSBF(sys, "concat", [a, b, c], r)
a.put(av)
b.put(bv)
c.put(cv)
sys.getSimulator().clk(1)
exception = False
except:
exception = True
assert (exception)
def test_1(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
r1 = sys.wire("r", 32)
py4hw.Constant(sys, "a", 10, a)
py4hw.Constant(sys, "b", 20, b)
py4hw.Add(sys, "add1", a, b, r1)
sys.getSimulator().clk(1)
assert (r1.get() == 30)
def test_integrity(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 2)
r = sys.wire("r", 1)
py4hw.Constant(sys, "a", 0, a)
py4hw.EqualConstant(sys, 'equal', a, 0, r)
py4hw.debug.checkIntegrity(sys)
def test_And_integrity(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
c = sys.wire("c", 32)
r = sys.wire("r", 32)
py4hw.Constant(sys, "a", 0xF7F7, a)
py4hw.Constant(sys, "b", 0x7685, b)
py4hw.Constant(sys, "c", 0x3452, c)
py4hw.And(sys, 'andx', [a, b, c], r)
py4hw.debug.checkIntegrity(sys)
def test_printHierarchyWithValuesFormat(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
c = sys.wire("c", 32)
r = sys.wire("r", 32)
py4hw.Constant(sys, "a", 0xF7F7, a)
py4hw.Constant(sys, "b", 0x7685, b)
py4hw.Constant(sys, "c", 0x3452, c)
py4hw.And(sys, 'andx', [a, b, c], r)
py4hw.debug.printHierarchyWithValues(sys, format="{}")
def test_notEqual(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 2)
r = sys.wire("r", 1)
py4hw.Constant(sys, "a", 3, a)
py4hw.EqualConstant(sys, 'equal', a, 0, r)
sys.getSimulator().clk(1)
assert (r.get() == 0)
def test_noneEqual(self):
sys = py4hw.HWSystem()
ins = sys.wires('wi', 3, 8)
py4hw.Constant(sys, 'i0', 3, ins[0])
py4hw.Constant(sys, 'i1', 7, ins[1])
py4hw.Constant(sys, 'i2', 9, ins[2])
r = sys.wire('r', 1)
py4hw.AnyEqual(sys, 'any', ins, r)
sys.getSimulator().clk(1)
assert (r.get() == 0)
def test_And(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
c = sys.wire("c", 32)
r = sys.wire("r", 32)
py4hw.Constant(sys, "a", 0xF7F7, a)
py4hw.Constant(sys, "b", 0x7685, b)
py4hw.Constant(sys, "c", 0x3452, c)
py4hw.And(sys, 'andx', [a, b, c], r)
sys.getSimulator().clk(1)
assert (r.get() == 0x3400)
def test_concat_lsbf_1(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 8)
b = sys.wire("b", 8)
r = sys.wire("r", 16)
av = 0x5F
bv = 0x37
py4hw.ConcatenateLSBF(sys, "concat", [a, b], r)
a.put(av)
b.put(bv)
sys.getSimulator().clk(1)
assert (r.get() == 0x375F)
def test_1(self):
sys = py4hw.HWSystem()
reset = sys.wire('reset', 1)
inc = sys.wire('inc', 1)
count = sys.wire('count', 8)
carry = sys.wire('carry', 1)
py4hw.Constant(sys, 'reset', 0, reset)
py4hw.Constant(sys, 'inc', 1, inc)
counter = py4hw.ModuloCounter(sys, 'counter', 3, reset, inc, count,
carry)
rtlgen = py4hw.VerilogGenerator(counter)
print(rtlgen.getVerilog())
def test_oneBitWire(self):
print('check values = 1')
sys = py4hw.HWSystem()
a = sys.wire("a", 1)
r = sys.wire("1", 1)
py4hw.Sequence(sys, "a", [0, 1], a)
py4hw.EqualConstant(sys, 'equal', a, 1, r)
for i in range(8):
sys.getSimulator().clk(1)
v = a.get()
exp = 1 if (v == 1) else 0
print(v, exp, r.get())
assert (r.get() == exp)
def test_random(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
r = sys.wire("r", 32)
py4hw.Abs(sys, "abs", a, r)
import random
for i in range(1000):
v = random.randint(-((1 << 31) - 1), (1 << 31) - 1)
a.put(v)
sys.getSimulator().clk(1)
assert (r.get() == abs(v))
def test_random(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
r = sys.wire("r")
py4hw.Sign(sys, "signTest1", a, r)
import random
for i in range(1000):
v = random.randint(-((1 << 31) - 1), (1 << 31) - 1)
a.put(v)
sys.getSimulator().clk(1)
assert (bool(r.get()) == (v < 0))
def test_Integrity(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
c = sys.wire("c", 32)
r1 = sys.wire("r", 32)
r2 = sys.wire("r2", 32)
py4hw.Add(sys, "add1", a, b, r1)
py4hw.Add(sys, "add2", r1, c, r2)
py4hw.Constant(sys, "a", 10, a)
py4hw.Constant(sys, "b", 20, b)
py4hw.Constant(sys, "c", 5, c)
py4hw.Scope(sys, "r2", r2)
py4hw.debug.checkIntegrity(sys)
def test_sub1(self):
sys = py4hw.HWSystem()
a = sys.wire('a', 23)
b = sys.wire('b', 23)
r = sys.wire('r', 24)
va = 1623049
vb = 6146853
vr = (va - vb) & ((1 << 24) - 1)
py4hw.Constant(sys, 'a', va, a)
py4hw.Constant(sys, 'b', vb, b)
py4hw.Sub(sys, 'r', a, b, r)
sys.getSimulator().clk(1)
assert (r.get() == vr)
def test_integrity(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 2)
bits = sys.wires('b', 2, 1)
minterm = sys.wire('minterm', 1)
py4hw.BitsLSBF(sys, 'bits', a, bits)
py4hw.Minterm(sys, 'minterm', bits, 0, minterm)
py4hw.Constant(sys, "a", 0, a)
for i in range(len(bits)):
py4hw.Scope(sys, 'b{}'.format(i), bits[i])
py4hw.Scope(sys, 'minterm_5', minterm)
py4hw.debug.checkIntegrity(sys)
def test_1(self):
sys = py4hw.HWSystem()
g = py4hw.LogicHelper(sys)
fp = py4hw.FloatingPointHelper()
r = sys.wire('r', 32)
av = 1.2
bv = 0.0000002
a = g.hw_constant(32, fp.sp_to_ieee754(av))
b = g.hw_constant(32, fp.sp_to_ieee754(bv))
fpa = py4hw.FPAdder_SP(sys, 'fpa', a, b, r)
sys.getSimulator().clk(1)
err = fp.ieee754_to_sp(r.get()) - (av + bv)
assert (abs(err) < 1E-7)
def test_equal5(self):
print('check values = 5')
sys = py4hw.HWSystem()
a = sys.wire("a", 3)
r = sys.wire("1", 1)
py4hw.Sequence(sys, "a", [0, 1, 2, 3, 4, 5, 6, 7], a)
py4hw.EqualConstant(sys, 'equal', a, 5, r)
for i in range(8):
sys.getSimulator().clk(1)
v = a.get()
rv = r.get()
exp = 1 if (v == 5) else 0
print(v, exp, rv)
assert (rv == exp)
def test_concat_lsbf_2(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 8)
b = sys.wire("b", 8)
c = sys.wire("c", 8)
r = sys.wire("r", 24)
av = 0x5F
bv = 0x37
cv = 0xD1
py4hw.ConcatenateLSBF(sys, "concat", [a, b, c], r)
a.put(av)
b.put(bv)
c.put(cv)
sys.getSimulator().clk(1)
assert (r.get() == 0xD1375F)
def test_random_inv(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
r = sys.wire("r", 32)
n = sys.wire("n")
py4hw.Abs(sys, "abs", a, r, inverted=n)
import random
for i in range(1000):
v = random.randint(-((1 << 31) - 1), (1 << 31) - 1)
a.put(v)
sys.getSimulator().clk(1)
assert (r.get() == abs(v))
assert (bool(n.get()) == (v < 0))
def test_msbf_3(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 1)
b = sys.wire("b", 8)
c = sys.wire("c", 23)
r = sys.wire("r", 32)
av = 0
bv = 127
cv = 2516585
ev = (127 << 23) | cv
py4hw.ConcatenateMSBF(sys, "concat", [a, b, c], r)
a.put(av)
b.put(bv)
c.put(cv)
sys.getSimulator().clk(1)
assert (r.get() == ev)
def test_EqualWire(self):
print('check values = 5')
sys = py4hw.HWSystem()
a = sys.wire("a", 3)
b = sys.wire("b", 3)
c = sys.wire("c", 3)
r1 = sys.wire("r1", 1)
r2 = sys.wire("r2", 1)
py4hw.Constant(sys, "a", 3, a)
py4hw.Constant(sys, "b", 3, b)
py4hw.Constant(sys, "c", 5, c)
py4hw.Equal(sys, 'equal1', a, b, r1)
py4hw.Equal(sys, 'equal2', a, c, r2)
sys.getSimulator().clk(1)
assert (r1.get() == 1)
assert (r2.get() == 0)
def test_2(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 5)
b = sys.wire("b", 7)
c = sys.wire("c", 11)
r = sys.wire("r", 32)
av = 11
bv = 23
cv = 111
ev = (((av << 7) | bv) << 11) | cv
py4hw.ConcatenateMSBF(sys, "concat", [a, b, c], r)
a.put(av)
b.put(bv)
c.put(cv)
sys.getSimulator().clk(1)
assert (r.get() == ev)
def test_integrity(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
c = sys.wire("c", 32)
sa = sys.wire("sa")
sb = sys.wire("sb")
sc = sys.wire("sc")
r = sys.wire("r", 32)
py4hw.Sequence(sys, "a", [1, 2, 3], a)
py4hw.Sequence(sys, "b", [1, 2, 3], b)
py4hw.Sequence(sys, "c", [1, 2, 3], c)
py4hw.Sequence(sys, "sa", [1, 0, 0], sa)
py4hw.Sequence(sys, "sb", [0, 1, 0], sb)
py4hw.Sequence(sys, "sc", [0, 0, 1], sc)
py4hw.Select(sys, 'select', [sa, sb, sc], [a, b, c], r)
py4hw.debug.checkIntegrity(sys)
def test_printHierarchy(self):
sys = py4hw.HWSystem()
a = sys.wire("a", 32)
b = sys.wire("b", 32)
c = sys.wire("c", 32)
r1 = sys.wire("r1", 32)
r2 = sys.wire("r2", 32)
r3 = sys.wire("r3", 32)
py4hw.And2(sys, "and1", a, b, r1)
py4hw.And2(sys, "and2", a, c, r2)
py4hw.And2(sys, "and3", b, c, r3)
py4hw.Constant(sys, "a", 0xF, a)
py4hw.Constant(sys, "b", 0xA, b)
py4hw.Constant(sys, "c", 0x5, c)
py4hw.Scope(sys, "r1 (0xF & 0xA)", r1)
py4hw.Scope(sys, "r2 (0xF & 0x5)", r2)
py4hw.Scope(sys, "r3 (0xA & 0x5)", r3)
py4hw.debug.printHierarchy(sys)
