def parallel_example(dut):
vi = [-32768, -1000, 0, 1000, 32767, -32768, -1000, 0, 1000, 32767]
vq = [-32768, -1000, 0, 1000, 32767, 32767, 1000, 0, -1000, -32768]
dut.data_en_i <= 0
reset_n = dut.rst_i
cocotb.fork(Clock(dut.clk_i, 10, 'ns').start())
yield reset_dut(reset_n, dut.clk_i, 500)
dut._log.debug("After reset")
yield FallingEdge(dut.clk_i)
yield FallingEdge(dut.clk_i)
for i in range(len(vi)):
dut.data_en_i <= 1
dut.data_i_i <= vi[i]
dut.data_q_i <= vq[i]
print(f"{i} {vi[i]} {vq[i]}")
yield FallingEdge(dut.clk_i)
dut.data_en_i <= 0
yield FallingEdge(dut.clk_i)
res = vq[i] * vq[i] + vi[i] * vi[i]
print(f"{res} {int(dut.data_o.value.signed_integer)}")
assert res == int(dut.data_o.value.signed_integer)
dut.data_en_i <= 0
async def _run_reset(self):
while True:
await RisingEdge(self.user_clk)
await RisingEdge(self.user_clk)
if self.user_reset is not None:
self.user_reset <= 1
if self.sys_reset is not None:
if not self.sys_reset.value:
await RisingEdge(self.sys_reset)
await First(FallingEdge(self.sys_reset), Timer(100, 'ns'))
await First(FallingEdge(self.sys_reset), RisingEdge(self.user_clk))
if not self.sys_reset.value:
continue
else:
await Timer(100, 'ns')
await RisingEdge(self.user_clk)
if self.user_reset is not None:
self.user_reset <= 0
if self.sys_reset is not None:
await FallingEdge(self.sys_reset)
else:
return
def _receive_data(self):
while True:
# Wait for a high TVALID, if not already high
if not self.bus.TVALID.value:
yield RisingEdge(self.bus.TVALID)
# Wait either for the required number of clock cycles or for a low
# TVALID. By AXI4-Stream standard, the master should not de-assert
# TVALID until at least one transfer has been performed but, if it
# does it anyways, just re-start the wait.
if callable(self.tready_delay):
tready_high_delay = ClockCycles(self.clock,
self.tready_delay(self.bus))
else:
tready_high_delay = ClockCycles(self.clock, self.tready_delay)
trigger = yield [tready_high_delay, FallingEdge(self.bus.TVALID)]
if trigger is tready_high_delay:
self.bus.TREADY <= 1
if callable(self.consecutive_transfers):
num_cycles = self.consecutive_transfers(self.bus)
else:
num_cycles = self.consecutive_transfers
if num_cycles != 0:
yield [ClockCycles(self.clock, num_cycles),
FallingEdge(self.bus.TVALID)]
else:
yield FallingEdge(self.bus.TVALID)
self.bus.TREADY <= 0
def rcv(self):
""" Monitor RX and add byte received to rx_buf list """
self._log.debug("launching rcv monitor")
onebaud = Timer(self._period + 300, units="ns") #XXX
frx = FallingEdge(self.rx)
rrx = RisingEdge(self.rx)
while True:
yield frx
# wait start bit
yield [onebaud, frx, rrx]
readingvalue = ""
for i in range(self.datasize):
readingvalue = "{:1d}".format(
self.rx.value.integer) + readingvalue
yield [onebaud, frx, rrx]
# read last bit
#wait stop bit
yield [onebaud, frx, rrx]
readingvalue = "0b" + readingvalue
self.rx_buf.append(int(readingvalue, 2))
if (int(readingvalue, 2) == 0x0D):
self._log.info("Read char \\r (value 0x0D)")
else:
self._log.info("Read char {} (value {:02X})".format(
chr(int(readingvalue, 2)), int(readingvalue, 2)))