def monitor(self): """ Initialize data reading if wait is 0 """ intf = self.intf yield WaitCombRead() if self.notReset(): # wait until wait signal is stable wait_last = None while True: yield WaitCombRead() wait = intf.wait.read() try: wait = int(wait) except ValueError: raise AssertionError(self.sim.now, intf, "wait signal in invalid state") if wait is wait_last: break else: wait_last = wait yield WaitWriteOnly() rd = not wait else: rd = False yield WaitWriteOnly() intf.en.write(rd) self.readPending = rd
def monitor(self): """Collect data from interface""" yield WaitCombRead() if self.notReset() and self._enabled: yield WaitWriteOnly() self.set_ready(1) yield WaitCombRead() d = self.get_data() self.data.append(d) else: yield WaitWriteOnly() self.set_ready(0)
def monitor(self): """ The evaluate a tristate 'i' value from 'o' and 't' and optionaly store it. One step. """ yield WaitCombRead() # read in pre-clock-edge t = self.t.read() o = self.o.read() sim = self.sim if self.pullMode is not None and sim.now > 0: try: t = int(t) except ValueError: raise AssertionError( sim.now, self.t, "Invalid value on tristate interface => ioblock would burn" ) try: o = int(o) except ValueError: raise AssertionError( sim.now, self.o, "Invalid value on tristate interface => ioblock would burn" ) if self.pullMode == o: raise AssertionError( sim.now, self.o, "Can not set value to a same as pull up," " because others may try to set it to oposite => ioblock would burn" ) if t: v = o else: v = self.pullMode last = self.i.read() try: last = int(last) except ValueError: last = None yield WaitWriteOnly() self.i.write(v) if self.collectData and sim.now > 0: yield WaitCombRead() if self.notReset(): self.data.append(v)
def driver(self): # now we are before clock event # * set wait signal # * set last data (done in separate process) # * if en == 1, pop next data for next clk intf = self.intf yield WaitCombRead() rst_n = self.notReset() # speculative write if rst_n and self.data: wait = 0 else: wait = 1 yield WaitWriteOnly() intf.wait.write(wait) if rst_n: # wait for potential update of en # check if write can be performed and if it possible do real write yield WaitTimeslotEnd() en = intf.en.read() try: en = int(en) except ValueError: raise AssertionError(self.sim.now, intf, "en signal in invalid state") if en: assert self.data, (self.sim.now, intf, "underflow") self.lastData = self.data.popleft()
def monitor(self): assert isinstance(self.period, int) assert isinstance(self.initWait, int) yield WaitCombRead() v = self.intf.read() try: v = int(v) except ValueError: v = None now = self.sim.now last = self.last _next = (now, v) if last[0] == now: if last[1] is not v: # update last value last = (now, v) self.last = last if self.data: self.data[-1] = last else: self.data.append(last) else: return else: self.data.append(_next) self.last = _next
def data_collect(): for d_ref in test_data: yield WaitCombRead() d = io.outp.read() d = int(d) r_data.append(d) self.assertEqual(d, d_ref) yield Timer(CLK_PERIOD)
def pull_up_after(): exp_t = sim.now yield WaitCombRead() assert sim.now == exp_t if not rst.read(): yield WaitWriteOnly() sig.write(1) assert sim.now == exp_t
def dataReader(self): yield Timer(1) if self.readPending: yield WaitCombRead() d = self.intf.data.read() self.data.append(d) if self.readPending_invalidate: self.readPending = False if not self.readPending and not self._enabled: self.dataWriter.setEnable(False)
def monitorWithTimer(self): if self.initPending and self.initDelay: yield Timer(self.initDelay) self.initPending = False # if there is no clk, we have to manage periodic call by our self while True: yield WaitCombRead() if self._enabled and self.notReset(): d = self.get_data() self.data.append(d) yield Timer(self.delay)
def driverWithClk(self): # if clock is specified this function is periodically called every # clk tick, if agent is enabled yield WaitCombRead() if not self._enabled: return if self.data and self.notReset(): yield WaitWriteOnly() if not self._enabled: return d = self.data.popleft() self.set_data(d)
def __call__(self): if self.pre_init: yield from self.fn() while True: yield Edge(self.sig) if self._enable and self.shouldBeEnabledFn(): yield WaitCombRead() if int(self.sig.read()) == 0: if self.isGenerator: yield from self.fn() else: self.fn()
def driver(self): # if wait == 0 set en=1 and set data intf = self.intf d = None v = 0 yield WaitCombRead() if self.notReset() and self.data: yield WaitCombRead() wait = intf.wait.read() try: wait = int(wait) except ValueError: raise AssertionError(self.sim.now, intf, "wait signal in invalid state") if not wait: d = self.data.popleft() v = 1 yield WaitWriteOnly() self.set_data(d) intf.en.write(v)
def get_pull_up_driver_with_reset(sim: HdlSimulator, sig, reset, clk_period): exp_t = 0 yield WaitWriteOnly() sig.write(0) assert sim.now == exp_t while True: yield WaitCombRead() if not reset.read(): assert sim.now == exp_t yield WaitWriteOnly() sig.write(1) return else: yield Timer(clk_period) exp_t += clk_period
def driver(self): yield WaitCombRead() if self.data and self.notReset(): d = self.data.popleft() else: d = NOP yield WaitWriteOnly() if d is NOP: self.set_data(None) self.set_valid(0) else: self.set_data(d) self.set_valid(1) if self._debugOutput is not None: self._debugOutput.write( "%s, wrote, %d: %r\n" % (self.intf._getFullName(), self.sim.now, self.actualData))
def monitor(self): # set wait signal # if en == 1 take data intf = self.intf yield WaitWriteOnly() intf.wait.write(0) yield WaitCombStable() # wait for potential update of en en = intf.en.read() try: en = int(en) except ValueError: raise AssertionError(self.sim.now, intf, "en signal in invalid state") if en: yield Timer(CLK_PERIOD / 10) yield WaitCombRead() self.data.append(self.get_data())
def driver(self): intf = self.intf if self.requireInit: yield WaitWriteOnly() intf.en.write(0) intf.we.write(0) self.requireInit = False readPending = self.readPending yield WaitCombRead() if self.requests and self.notReset(): yield WaitWriteOnly() req = self.requests.popleft() if req is NOP: intf.en.write(0) intf.we.write(0) self.readPending = False else: self.doReq(req) intf.en.write(1) else: yield WaitWriteOnly() intf.en.write(0) intf.we.write(0) self.readPending = False if readPending: # in previous clock the read request was dispatched, now we are collecting the data yield WaitCombStable() # now we are after clk edge d = intf.dout.read() self.r_data.append(d) if self._debugOutput is not None: self._debugOutput.write("%s, on %r read_data: %d\n" % ( self.intf._getFullName(), self.sim.now, d.val))
def driver(self): """Push data to interface""" yield WaitWriteOnly() if self.actualData is NOP and self.data: self.actualData = self.data.popleft() do = self.actualData is not NOP if do: self.set_data(self.actualData) else: self.set_data(None) yield WaitCombRead() en = self.notReset() and self._enabled if not (en and do): return if en: rd = self.get_ready() try: rd = int(rd) except ValueError: raise AssertionError( ("%r: ready signal for interface %r is in invalid state," " this would cause desynchronization") % (self.sim.now, self.intf)) if rd: if self._debugOutput is not None: self._debugOutput.write("%s, wrote, %d: %r\n" % (self.intf._getFullName(), self.sim.now, self.actualData)) if self.data: self.actualData = self.data.popleft() else: self.actualData = NOP
def monitor(self): """ Collect data from interface """ start = self.sim.now yield WaitCombRead() if not self._enabled: return if self.notReset(): yield WaitWriteOnly() if not self._enabled: return # update rd signal only if required if self._lastRd is not 1: self.set_ready(1) self._lastRd = 1 # try to run onMonitorReady if there is any try: onMonitorReady = self.onMonitorReady except AttributeError: onMonitorReady = None if onMonitorReady is not None: onMonitorReady() else: yield WaitCombRead() assert int(self.get_ready()) == self._lastRd, ( "Something changed the value of ready withou notifying of this agent" " which is responsible for this", self.sim.now, self.get_ready(), self._lastRd) if not self._enabled: return if not self._enabled: return # wait for response of master yield WaitCombStable() if not self._enabled: return vld = self.get_valid() try: vld = int(vld) except ValueError: raise AssertionError( self.sim.now, self.intf, "vld signal is in invalid state") if vld: # master responded with positive ack, do read data d = self.get_data() if self._debugOutput is not None: self._debugOutput.write( "%s, read, %d: %r\n" % ( self.intf._getFullName(), self.sim.now, d)) self.data.append(d) if self._afterRead is not None: self._afterRead() else: if self._lastRd is not 0: yield WaitWriteOnly() # can not receive, say it to masters self.set_ready(0) self._lastRd = 0 else: assert int(self.get_ready()) == self._lastRd assert start == self.sim.now
def driver(self): """ Push data to interface set vld high and wait on rd in high then pass new data """ start = self.sim.now yield WaitWriteOnly() if not self._enabled: return # pop new data if there are not any pending if self.actualData is NOP and self.data: self.actualData = self.data.popleft() doSend = self.actualData is not NOP # update data on signals if is required if self.actualData is not self._lastWritten: if doSend: data = self.actualData else: data = None self.set_data(data) self._lastWritten = self.actualData yield WaitCombRead() if not self._enabled: return en = self.notReset() vld = int(en and doSend) if self._lastVld is not vld: yield WaitWriteOnly() self.set_valid(vld) self._lastVld = vld if not self._enabled: # we can not check rd it in this function because we can not wait # because we can be reactivated in this same time yield self.checkIfRdWillBeValid() return # wait for response of slave yield WaitCombStable() if not self._enabled: return rd = self.get_ready() try: rd = int(rd) except ValueError: raise AssertionError( self.sim.now, self.intf, "rd signal in invalid state") from None if not vld: assert start == self.sim.now return if rd: # slave did read data, take new one if self._debugOutput is not None: self._debugOutput.write("%s, wrote, %d: %r\n" % ( self.intf._getFullName(), self.sim.now, self.actualData)) a = self.actualData # pop new data, because actual was read by slave if self.data: self.actualData = self.data.popleft() else: self.actualData = NOP # try to run onDriverWriteAck if there is any onDriverWriteAck = getattr(self, "onDriverWriteAck", None) if onDriverWriteAck is not None: onDriverWriteAck() onDone = getattr(a, "onDone", None) if onDone is not None: onDone() assert start == self.sim.now
def monitorWithClk(): # if clock is specified this function is periodically called every # clk tick yield WaitCombRead() if not rst.read(): result.append((sim.now, int(sig.read())))
def monitor(self): """ Collect data from interface If onMonitorReady is present run it before setting ready and before data is read from the channel """ start = self.sim.now yield WaitCombRead() if not self._enabled: return if self.notReset(): yield WaitWriteOnly() if not self._enabled: return if self._readyComnsummed: # try to run onMonitorReady if there is any to preset value on signals potentially # going against main data flow of this channel onMonitorReady = getattr(self, "onMonitorReady", None) if onMonitorReady is not None: onMonitorReady() self._readyComnsummed = False # update rd signal only if required if self._lastRd != 1: self.set_ready(1) self._lastRd = 1 else: yield WaitCombRead() assert int(self.get_ready()) == self._lastRd, ( "Something changed the value of ready without notifying this agent" " which is responsible for this", self.sim.now, self.get_ready(), self._lastRd) if not self._enabled: return # wait for response of master yield WaitCombStable() if not self._enabled: return vld = self.get_valid() try: vld = int(vld) except ValueError: raise AssertionError(self.sim.now, self.intf, "vld signal is in invalid state") if vld: # master responded with positive ack, do read data d = self.get_data() if self._debugOutput is not None: name = self.intf._getFullName() self._debugOutput.write( f"{name:s}, read, {self.sim.now:d}: {d}\n") self.data.append(d) if self._afterRead is not None: self._afterRead() # data was read from th channel next ready bellongs to a different data chunk self._readyComnsummed = True else: self._readyComnsummed = True if self._lastRd != 0: yield WaitWriteOnly() # can not receive, say it to masters self.set_ready(0) self._lastRd = 0 else: assert int(self.get_ready()) == self._lastRd assert start == self.sim.now