| Line 6... |
Line 6... |
from myhdl import delay, now, Signal, intbv, ResetSignal, Simulation, \
|
from myhdl import delay, now, Signal, intbv, ResetSignal, Simulation, \
|
Cosimulation, block, instance, StopSimulation, modbv, \
|
Cosimulation, block, instance, StopSimulation, modbv, \
|
always, always_seq, always_comb, enum, Error
|
always, always_seq, always_comb, enum, Error
|
|
|
from deflate import IDLE, WRITE, READ, STARTC, STARTD, LBSIZE, IBSIZE, \
|
from deflate import IDLE, WRITE, READ, STARTC, STARTD, LBSIZE, IBSIZE, \
|
CWINDOW, COMPRESS
|
CWINDOW, COMPRESS, DECOMPRESS, OBSIZE, LMAX, LIBSIZE
|
|
|
MAXW = 2 * CWINDOW
|
MAXW = CWINDOW
|
|
|
COSIMULATION = True
|
COSIMULATION = True
|
COSIMULATION = False
|
COSIMULATION = False
|
|
|
if not COSIMULATION:
|
if not COSIMULATION:
|
from deflate import deflate
|
from deflate import deflate
|
else:
|
else:
|
def deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
def deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
o_byte, i_addr, clk, reset):
|
o_byte, i_waddr, i_raddr, clk, reset):
|
print("Cosimulation")
|
print("Cosimulation")
|
cmd = "iverilog -o deflate " + \
|
cmd = "iverilog -o deflate " + \
|
"deflate.v " + \
|
"deflate.v " + \
|
"tb_deflate.v " # "dump.v "
|
"tb_deflate.v " # "dump.v "
|
os.system(cmd)
|
os.system(cmd)
|
return Cosimulation("vvp -m ./myhdl deflate",
|
return Cosimulation("vvp -m ./myhdl deflate",
|
i_mode=i_mode, o_done=o_done,
|
i_mode=i_mode, o_done=o_done,
|
i_data=i_data, o_iprogress=o_iprogress,
|
i_data=i_data, o_iprogress=o_iprogress,
|
o_oprogress=o_oprogress,
|
o_oprogress=o_oprogress,
|
o_byte=o_byte, i_addr=i_addr,
|
o_byte=o_byte, i_waddr=i_waddr, i_raddr=i_raddr,
|
clk=clk, reset=reset)
|
clk=clk, reset=reset)
|
|
|
|
|
def test_data(m):
|
def test_data(m, tlen=100, limit=False):
|
print("MODE", m)
|
print("MODE", m, tlen)
|
if m == 0:
|
if m == 0:
|
str_data = " ".join(["Hello World! " + str(1) + " "
|
str_data = " ".join(["Hello World! " + str(1) + " "
|
for i in range(100)])
|
for i in range(tlen)])
|
b_data = str_data.encode('utf-8')
|
b_data = str_data.encode('utf-8')
|
elif m == 1:
|
elif m == 1:
|
str_data = " ".join([" Hello World! " + str(i) + " "
|
str_data = " ".join([" Hello World! " + str(i) + " "
|
# str_data = " ".join(["Hello World! " + str(i) + " "
|
for i in range(tlen)])
|
for i in range(5)])
|
|
b_data = str_data.encode('utf-8')
|
b_data = str_data.encode('utf-8')
|
elif m == 2:
|
elif m == 2:
|
str_data = " ".join(["Hi: " + str(random.randrange(0,0x1000)) + " "
|
str_data = " ".join(["Hi: " + str(random.randrange(0,0x1000)) + " "
|
for i in range(100)])
|
for i in range(tlen)])
|
b_data = str_data.encode('utf-8')
|
b_data = str_data.encode('utf-8')
|
elif m == 3:
|
elif m == 3:
|
b_data = bytes([random.randrange(0,0x100) for i in range(100)])
|
b_data = bytes([random.randrange(0,0x100) for i in range(tlen)])
|
elif m == 4:
|
elif m == 4:
|
str_data = "".join([str(random.randrange(0,2))
|
str_data = "".join([str(random.randrange(0,2))
|
for i in range(1000)])
|
for i in range(tlen)])
|
b_data = str_data.encode('utf-8')
|
b_data = str_data.encode('utf-8')
|
else:
|
else:
|
raise Error("unknown test mode")
|
raise Error("unknown test mode")
|
# print(str_data)
|
# print(str_data)
|
b_data = b_data[:IBSIZE - 4 - 20]
|
if limit:
|
|
b_data = b_data[:IBSIZE - 4 - 10]
|
zl_data = zlib.compress(b_data)
|
zl_data = zlib.compress(b_data)
|
print("From %d to %d bytes" % (len(b_data), len(zl_data)))
|
print("From %d to %d bytes" % (len(b_data), len(zl_data)))
|
print(zl_data)
|
print(zl_data[:500])
|
return b_data, zl_data
|
return b_data, zl_data
|
|
|
|
|
class TestDeflate(unittest.TestCase):
|
class TestDeflate(unittest.TestCase):
|
|
|
def testMain(self):
|
def testMain(self):
|
|
|
def test_decompress(i_mode, o_done, i_data, o_iprogress,
|
def test_decompress(i_mode, o_done, i_data, o_iprogress,
|
o_oprogress, o_byte, i_addr, clk, reset):
|
o_oprogress, o_byte, i_waddr, i_raddr, clk, reset):
|
|
|
def tick():
|
def tick():
|
clk.next = not clk
|
clk.next = not clk
|
|
|
print("")
|
print("")
|
print("==========================")
|
print("==========================")
|
print("START TEST MODE", mode)
|
print("START TEST MODE", mode)
|
print("==========================")
|
print("==========================")
|
|
|
b_data, zl_data = test_data(mode)
|
b_data, zl_data = test_data(mode, 25000)
|
|
|
|
if mode == 0:
|
reset.next = 0
|
reset.next = 0
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
reset.next = 1
|
reset.next = 1
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
|
|
print("STARTD")
|
if DECOMPRESS:
|
i_mode.next = STARTD
|
print("==========STREAMING DECOMPRESS TEST=========")
|
tick()
|
|
yield delay(5)
|
|
tick()
|
|
yield delay(5)
|
|
i_mode.next = IDLE
|
|
|
|
print("WRITE")
|
print("STREAM LENGTH", len(zl_data))
|
i_mode.next = WRITE
|
|
i = 0
|
i_mode.next = IDLE
|
while i < len(zl_data):
|
|
if o_iprogress > i - MAXW:
|
|
# print("write", i)
|
|
i_data.next = zl_data[i]
|
|
i_addr.next = i
|
|
i = i + 1
|
|
else:
|
|
# print("Wait for space")
|
|
pass
|
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
i_mode.next = IDLE
|
|
print("Wrote input, wait for end of decompression")
|
|
|
|
# alternative without sliding window:
|
print("STARTD")
|
"""
|
i_mode.next = STARTD
|
print("WRITE")
|
|
i_mode.next = WRITE
|
|
for i in range(len(zl_data)):
|
|
i_data.next = zl_data[i]
|
|
i_addr.next = i
|
|
tick()
|
|
yield delay(5)
|
|
tick()
|
|
yield delay(5)
|
|
i_mode.next = IDLE
|
|
|
|
print("STARTD")
|
|
i_mode.next = STARTD
|
|
tick()
|
|
yield delay(5)
|
|
tick()
|
|
yield delay(5)
|
|
i_mode.next = IDLE
|
|
"""
|
|
|
|
print(now())
|
|
while not o_done:
|
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
print(now())
|
|
|
|
last = o_oprogress
|
print("WRITE")
|
print("GOT", last)
|
i = 0
|
|
ri = 0
|
|
first = 1
|
|
sresult = []
|
|
start = now()
|
|
wait = 0
|
|
while True:
|
|
if ri >= 1000 and ri % 10000 == 0:
|
|
print(ri)
|
|
if ri < o_oprogress:
|
|
did_read = 1
|
|
# print("do read", ri, o_oprogress)
|
i_mode.next = READ
|
i_mode.next = READ
|
d_data = []
|
i_raddr.next = ri
|
for i in range(last):
|
|
i_addr.next = i
|
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
d_data.append(bytes([o_byte]))
|
ri = ri + 1
|
i_mode.next = IDLE
|
else:
|
|
did_read = 0
|
d_data = b''.join(d_data)
|
|
|
|
self.assertEqual(b_data, d_data, "decompress does NOT match")
|
|
print(len(d_data), len(zl_data))
|
|
|
|
print("==========COMPRESS TEST=========")
|
|
|
|
|
if i < len(zl_data):
|
|
if o_iprogress > i - MAXW:
|
i_mode.next = WRITE
|
i_mode.next = WRITE
|
for i in range(len(b_data)):
|
i_waddr.next = i
|
i_data.next = b_data[i]
|
i_data.next = zl_data[i]
|
i_addr.next = i
|
# print("write", i, zl_data[i])
|
tick()
|
i = i + 1
|
yield delay(5)
|
else:
|
tick()
|
# print("Wait for space", i)
|
yield delay(5)
|
wait += 1
|
|
else:
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
|
|
i_mode.next = STARTC
|
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
i_mode.next = IDLE
|
|
|
|
print(now())
|
if did_read:
|
while not o_done:
|
# print("read", ri, o_oprogress, o_byte)
|
tick()
|
sresult.append(bytes([o_byte]))
|
yield delay(5)
|
|
tick()
|
|
yield delay(5)
|
|
print(now())
|
|
|
|
# raise Error("STOP")
|
if o_done:
|
|
# print("DONE", o_oprogress, ri)
|
|
if o_oprogress == ri:
|
|
break;
|
|
|
last = o_oprogress
|
i_mode.next = IDLE
|
print("last", last)
|
|
i_mode.next = READ
|
|
c_data = []
|
|
for i in range(last):
|
|
i_addr.next = i
|
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
c_data.append(bytes([o_byte]))
|
|
i_mode.next = IDLE
|
|
|
|
print("b_data:", len(b_data), b_data)
|
print("IN/OUT/CYCLES/WAIT", len(zl_data), len(sresult),
|
c_data = b''.join(c_data)
|
(now() - start) // 10, wait)
|
print("c_data:", len(c_data), c_data)
|
sresult = b''.join(sresult)
|
print("zl_data:", len(zl_data), zl_data)
|
self.assertEqual(b_data, sresult)
|
|
# self.assertEqual(b_data[:100000], sresult[:100000])
|
|
print("Decompress OK!")
|
|
|
print("zlib test:", zlib.decompress(c_data))
|
print("==========STREAMING COMPRESS TEST=========")
|
|
|
print("WRITE COMPRESSED RESULT")
|
print("STARTC")
|
i_mode.next = WRITE
|
i_mode.next = STARTC
|
for i in range(len(c_data)):
|
|
i_data.next = c_data[i]
|
|
i_addr.next = i
|
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
i_mode.next = IDLE
|
|
|
|
print("STARTD after Compress")
|
print("WRITE")
|
i_mode.next = STARTD
|
i = 0
|
|
ri = 0
|
|
slen = 25000
|
|
sresult = []
|
|
wait = 0
|
|
start = now()
|
|
while True:
|
|
if ri < o_oprogress:
|
|
did_read = 1
|
|
# print("do read", ri, o_oprogress)
|
|
i_mode.next = READ
|
|
i_raddr.next = ri
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
|
if ri % 10000 == 0:
|
|
print(ri)
|
|
ri = ri + 1
|
|
else:
|
|
did_read = 0
|
|
|
|
if i < slen:
|
|
if o_iprogress > i - MAXW:
|
|
i_mode.next = WRITE
|
|
i_waddr.next = i
|
|
i_data.next = b_data[i % len(b_data)]
|
|
# print("write", i, b_data[i % len(b_data)])
|
|
i = i + 1
|
|
else:
|
|
# print("Wait for space", i)
|
|
wait += 1
|
|
else:
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
|
|
print(now())
|
|
while not o_done:
|
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
tick()
|
tick()
|
yield delay(5)
|
yield delay(5)
|
print(now())
|
|
|
|
last = o_oprogress
|
if did_read:
|
i_mode.next = READ
|
# print("read", ri, o_oprogress, o_byte)
|
d_data = []
|
sresult.append(bytes([o_byte]))
|
for i in range(last):
|
|
i_addr.next = i
|
if o_done:
|
tick()
|
# print("DONE", o_oprogress, ri)
|
yield delay(5)
|
if o_oprogress == ri:
|
tick()
|
break;
|
yield delay(5)
|
|
d_data.append(bytes([o_byte]))
|
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
|
|
d_data = b''.join(d_data)
|
print("IN/OUT/CYCLES/WAIT", slen, len(sresult),
|
|
(now() - start) // 10, wait)
|
|
sresult = b''.join(sresult)
|
|
print("zlib test:", zlib.decompress(sresult)[:60])
|
|
rlen = min(len(b_data), slen)
|
|
self.assertEqual(zlib.decompress(sresult)[:rlen], b_data[:rlen])
|
|
print("DONE!")
|
|
|
self.assertEqual(b_data, d_data, "decompress after compress does NOT match")
|
|
print(len(b_data), len(zl_data), len(c_data))
|
|
|
|
for loop in range(1):
|
for loop in range(1):
|
for mode in range(5):
|
for mode in range(5):
|
|
# for mode in range(2,3):
|
self.runTests(test_decompress)
|
self.runTests(test_decompress)
|
|
|
def runTests(self, test):
|
def runTests(self, test):
|
"""Helper method to run the actual tests."""
|
"""Helper method to run the actual tests."""
|
|
|
i_mode = Signal(intbv(0)[3:])
|
i_mode = Signal(intbv(0)[3:])
|
o_done = Signal(bool(0))
|
o_done = Signal(bool(0))
|
|
|
i_data = Signal(intbv()[8:])
|
i_data = Signal(intbv()[8:])
|
o_byte = Signal(intbv()[8:])
|
o_byte = Signal(intbv()[8:])
|
o_iprogress = Signal(intbv()[LBSIZE:])
|
o_iprogress = Signal(intbv()[LMAX:])
|
o_oprogress = Signal(intbv()[LBSIZE:])
|
o_oprogress = Signal(intbv()[LMAX:])
|
i_addr = Signal(intbv()[LBSIZE:])
|
i_waddr = Signal(modbv()[LMAX:])
|
|
i_raddr = Signal(modbv()[LMAX:])
|
|
|
clk = Signal(bool(0))
|
clk = Signal(bool(0))
|
reset = ResetSignal(1, 0, True)
|
reset = ResetSignal(1, 0, True)
|
|
|
dut = deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
dut = deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
o_byte, i_addr, clk, reset)
|
o_byte, i_waddr, i_raddr, clk, reset)
|
|
|
check = test(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
check = test(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
o_byte, i_addr, clk, reset)
|
o_byte, i_waddr, i_raddr, clk, reset)
|
sim = Simulation(dut, check)
|
sim = Simulation(dut, check)
|
# traceSignals(dut)
|
# traceSignals(dut)
|
sim.run(quiet=1)
|
sim.run(quiet=1)
|
|
|
|
|
SLOWDOWN = 1
|
SLOWDOWN = 1
|
|
|
@block
|
@block
|
def test_deflate_bench(i_clk, o_led, led0_g, led1_b, led2_r):
|
def test_deflate_bench(i_clk, o_led, led0_g, led1_b, led2_r):
|
|
|
u_data, c_data = test_data(1)
|
u_data, c_data = test_data(1, 100, IBSIZE)
|
|
|
CDATA = tuple(c_data)
|
CDATA = tuple(c_data)
|
UDATA = tuple(u_data)
|
UDATA = tuple(u_data)
|
|
|
i_mode = Signal(intbv(0)[3:])
|
i_mode = Signal(intbv(0)[3:])
|
o_done = Signal(bool(0))
|
o_done = Signal(bool(0))
|
|
|
i_data = Signal(intbv()[8:])
|
i_data = Signal(intbv()[8:])
|
o_byte = Signal(intbv()[8:])
|
o_byte = Signal(intbv()[8:])
|
u_data = Signal(intbv()[8:])
|
u_data = Signal(intbv()[8:])
|
o_iprogress = Signal(intbv()[LBSIZE:])
|
o_iprogress = Signal(intbv()[LMAX:])
|
o_oprogress = Signal(intbv()[LBSIZE:])
|
o_oprogress = Signal(intbv()[LMAX:])
|
resultlen = Signal(intbv()[LBSIZE:])
|
resultlen = Signal(intbv()[LMAX:])
|
i_addr = Signal(intbv()[LBSIZE:])
|
i_waddr = Signal(modbv()[LMAX:])
|
|
i_raddr = Signal(modbv()[LBSIZE:])
|
|
|
reset = ResetSignal(1, 0, True)
|
reset = ResetSignal(1, 0, True)
|
|
|
dut = deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
dut = deflate(i_mode, o_done, i_data, o_iprogress, o_oprogress,
|
o_byte, i_addr, i_clk, reset)
|
o_byte, i_waddr, i_raddr, i_clk, reset)
|
|
|
tb_state = enum('RESET', 'START', 'WRITE', 'DECOMPRESS', 'WAIT', 'VERIFY',
|
tb_state = enum('RESET', 'START', 'WRITE', 'DECOMPRESS', 'WAIT', 'VERIFY',
|
'PAUSE', 'CWRITE', 'COMPRESS', 'CWAIT', 'CRESULT',
|
'PAUSE', 'CWRITE', 'COMPRESS', 'CWAIT', 'CRESULT',
|
'VWRITE', 'VDECOMPRESS', 'VWAIT', 'CVERIFY', 'CPAUSE',
|
'VWRITE', 'VDECOMPRESS', 'VWAIT', 'CVERIFY', 'CPAUSE',
|
'FAIL', 'HALT')
|
'FAIL', 'HALT')
|
| Line 382... |
Line 369... |
o_led.next = tbi
|
o_led.next = tbi
|
led1_b.next = o_done
|
led1_b.next = o_done
|
led2_r.next = not led2_r
|
led2_r.next = not led2_r
|
i_mode.next = WRITE
|
i_mode.next = WRITE
|
i_data.next = CDATA[tbi]
|
i_data.next = CDATA[tbi]
|
i_addr.next = tbi
|
i_waddr.next = tbi
|
tbi.next = tbi + 1
|
tbi.next = tbi + 1
|
else:
|
else:
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
led2_r.next = 0
|
led2_r.next = 0
|
tstate.next = tb_state.DECOMPRESS
|
tstate.next = tb_state.DECOMPRESS
|
| Line 398... |
Line 385... |
elif tstate == tb_state.WAIT:
|
elif tstate == tb_state.WAIT:
|
led1_b.next = not led1_b
|
led1_b.next = not led1_b
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
if i_mode == IDLE and o_done:
|
if i_mode == IDLE and o_done:
|
print("result len", o_oprogress)
|
print("result len", o_oprogress)
|
if o_oprogress == 0x4F:
|
|
tstate.next = tb_state.HALT
|
|
resultlen.next = o_oprogress
|
resultlen.next = o_oprogress
|
tbi.next = 0
|
tbi.next = 0
|
i_addr.next = 0
|
i_raddr.next = 0
|
i_mode.next = READ
|
i_mode.next = READ
|
wtick.next = True
|
wtick.next = True
|
tstate.next = tb_state.VERIFY
|
tstate.next = tb_state.VERIFY
|
"""
|
|
if o_oprogress == 0x4F:
|
|
tstate.next = tb_state.HALT
|
|
else:
|
|
tstate.next = tb_state.FAIL
|
|
"""
|
|
|
|
elif tstate == tb_state.VERIFY:
|
elif tstate == tb_state.VERIFY:
|
# print("VERIFY", o_data)
|
# print("VERIFY", o_data)
|
led1_b.next = 0
|
led1_b.next = 0
|
o_led.next = tbi
|
o_led.next = tbi
|
| Line 439... |
Line 418... |
# tstate.next = tb_state.RESET
|
# tstate.next = tb_state.RESET
|
raise Error("bad result")
|
raise Error("bad result")
|
else:
|
else:
|
pass
|
pass
|
# print(tbi, o_data)
|
# print(tbi, o_data)
|
i_addr.next = tbi + 1
|
i_raddr.next = tbi + 1
|
tbi.next = tbi + 1
|
tbi.next = tbi + 1
|
wtick.next = True
|
wtick.next = True
|
else:
|
else:
|
print(len(UDATA))
|
print(len(UDATA))
|
print("DECOMPRESS test OK!, pausing", tbi)
|
print("DECOMPRESS test OK!, pausing", tbi)
|
| Line 480... |
Line 459... |
# print(tbi)
|
# print(tbi)
|
led2_r.next = 0
|
led2_r.next = 0
|
led1_b.next = not led1_b
|
led1_b.next = not led1_b
|
i_mode.next = WRITE
|
i_mode.next = WRITE
|
i_data.next = UDATA[tbi]
|
i_data.next = UDATA[tbi]
|
i_addr.next = tbi
|
i_waddr.next = tbi
|
tbi.next = tbi + 1
|
tbi.next = tbi + 1
|
else:
|
else:
|
print("wrote bytes to compress", tbi)
|
print("wrote bytes to compress", tbi)
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
tstate.next = tb_state.COMPRESS
|
tstate.next = tb_state.COMPRESS
|
| Line 501... |
Line 480... |
led1_b.next = 0
|
led1_b.next = 0
|
elif o_done:
|
elif o_done:
|
print("result len", o_oprogress)
|
print("result len", o_oprogress)
|
resultlen.next = o_oprogress
|
resultlen.next = o_oprogress
|
tbi.next = 0
|
tbi.next = 0
|
i_addr.next = 0
|
i_raddr.next = 0
|
i_mode.next = READ
|
i_mode.next = READ
|
tstate.next = tb_state.CRESULT
|
tstate.next = tb_state.CRESULT
|
wtick.next = True
|
wtick.next = True
|
|
|
# verify compression
|
# verify compression
|
| Line 515... |
Line 494... |
o_led.next = tbi
|
o_led.next = tbi
|
if wtick:
|
if wtick:
|
if tbi > 0:
|
if tbi > 0:
|
i_mode.next = WRITE
|
i_mode.next = WRITE
|
i_data.next = copy
|
i_data.next = copy
|
i_addr.next = tbi - 1
|
i_waddr.next = tbi - 1
|
wtick.next = False
|
wtick.next = False
|
tbi.next = tbi + 1
|
tbi.next = tbi + 1
|
elif tbi < resultlen:
|
elif tbi < resultlen:
|
i_mode.next = READ
|
i_mode.next = READ
|
led1_b.next = not led1_b
|
led1_b.next = not led1_b
|
i_addr.next = tbi
|
i_raddr.next = tbi
|
copy.next = o_byte
|
copy.next = o_byte
|
wtick.next = True
|
wtick.next = True
|
else:
|
else:
|
print("Compress output bytes copied to input", resultlen, tbi - 1)
|
print("Compress output bytes copied to input", resultlen, tbi - 1)
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
| Line 542... |
Line 521... |
led1_b.next = not led1_b
|
led1_b.next = not led1_b
|
i_mode.next = IDLE
|
i_mode.next = IDLE
|
if i_mode == IDLE and o_done:
|
if i_mode == IDLE and o_done:
|
print("DONE DECOMPRESS VERIFY", o_oprogress)
|
print("DONE DECOMPRESS VERIFY", o_oprogress)
|
tbi.next = 0
|
tbi.next = 0
|
i_addr.next = 0
|
i_raddr.next = 0
|
i_mode.next = READ
|
i_mode.next = READ
|
wtick.next = True
|
wtick.next = True
|
tstate.next = tb_state.CVERIFY
|
tstate.next = tb_state.CVERIFY
|
|
|
elif tstate == tb_state.CVERIFY:
|
elif tstate == tb_state.CVERIFY:
|
| Line 564... |
Line 543... |
i_mode.next = IDLE
|
i_mode.next = IDLE
|
print("FAIL", len(UDATA), tbi, ud2, o_byte)
|
print("FAIL", len(UDATA), tbi, ud2, o_byte)
|
raise Error("bad result")
|
raise Error("bad result")
|
tstate.next = tb_state.FAIL
|
tstate.next = tb_state.FAIL
|
tbi.next = tbi + 1
|
tbi.next = tbi + 1
|
i_addr.next = tbi + 1
|
i_raddr.next = tbi + 1
|
wtick.next = True
|
wtick.next = True
|
else:
|
else:
|
print(len(UDATA))
|
print(len(UDATA))
|
print("ALL OK!", tbi)
|
print("ALL OK!", tbi)
|
led2_r.next = 0
|
led2_r.next = 0
|
