def handleMessage(self, msg): if msg is self.endServiceMsg: self.endService(self.msgServiced) if self.queue.isEmpty(): self.msgServiced = None self.emit(self.busySignal, False) else: self.msgServiced = self.queue.pop() self.emit(self.qlenSignal, self.queue.getLength()) self.emit(self.queueingTimeSignal, simTime() - self.msgServiced.getTimestamp()) serviceTime = self.startService(self.msgServiced) self.scheduleAt(simTime() + serviceTime, self.endServiceMsg) elif not self.msgServiced: self.arrival(msg) self.msgServiced = msg self.emit(self.queueingTimeSignal, SIMTIME_ZERO) serviceTime = self.startService(self.msgServiced) self.scheduleAt(simTime() + serviceTime, self.endServiceMsg) self.emit(self.busySignal, True) else: self.arrival(msg) self.queue.insert(msg) msg.setTimestamp() self.emit(self.qlenSignal, self.queue.getLength())
def handleMessage(self, msg): # move distance = self.speed * self.timeStep.dbl() self.loc.x += distance * math.cos(self.heading) self.loc.y += distance * math.sin(self.heading) target = self.road.getPoint(self.targetPointIndex) vectorToTarget = target - self.loc if vectorToTarget.getLength() < 50: # reached self.targetPointIndex = (self.targetPointIndex + 1) % self.road.getNumPoints() targetDirection = math.atan2(vectorToTarget.y, vectorToTarget.x) diff = targetDirection - self.heading while diff < -math.pi: diff += 2 * math.pi while diff > math.pi: diff -= 2 * math.pi # steer self.heading += self.angularSpeed * self.timeStep.dbl() self.angularSpeed = diff / 30 self.distanceTravelled += distance self.refreshDisplay() self.trail.addPoint(self.loc) if self.trail.getNumPoints() > 500: self.trail.removePoint(0) self.lastStep = simTime() self.scheduleAt(simTime() + self.timeStep, msg)
def initialize(self): self.timeStep = SimTime(1) self.speed = 2 self.heading = 0 self.angularSpeed = 0 self.targetPointIndex = 0 self.distanceTravelled = 0 canvas = self.getParentModule().getCanvas() canvas.setAnimationSpeed(50.0, self) self.road = canvas.getFigure("road") self.trail = canvas.getFigure("trail").asPolylineFigure() self.car = canvas.getFigure("car") self.antenna = canvas.getFigureByPath("car.antenna") self.distanceDisplay = canvas.getFigureByPath("status.distance") self.headingDisplay = canvas.getFigureByPath("status.heading") self.loc = self.road.getPoint(self.targetPointIndex) WATCH('timeStep') WATCH('loc.x') WATCH('loc.y') WATCH('speed') WATCH('heading') WATCH('angularSpeed') WATCH('targetPointIndex') WATCH('distanceTravelled') self.refreshDisplay() self.scheduleAt(simTime(), cMessage())
def handleMessage(self, msg): lifetime = simTime() - msg.getCreationTime() EV << "Received " << msg.getName( ) << ", lifetime: " << lifetime << "s" << '\n' self.emit(self.lifetimeSignal, lifetime) self.delete(msg) msg = None
def getNextTransmissionTime(self): t = simTime() + self.iaTime.doubleValue() if not self.isSlotted: return t else: # align time of next transmission to a slot boundary return self.slotTime * math.ceil(t / self.slotTime)
def handleMessage(self, msg): if (self.statisticObjects[0].getCount() == self.count): EV << "done" << '\n' self.delete(msg) msg = None return if not self.weighted: value = self.par("variable").doubleValue() EV << "collecting value=" << value << '\n' self.valuesVector.record(value) self.emit(self.unweightedValueSignal, value) for statistic in self.statisticObjects: statistic.collect(value) else: value = par("variable").doubleValue() weight = par("weight").doubleValue() EV << "collecting value=" << value << " with weight=" << weight << '\n' self.valuesVector.record(value) self.weightsVector.record(weight) self.emit(self.unweightedValueSignal, value) for statistic in self.statisticObjects: statistic.collectWeighted(value, weight) self.scheduleAt(simTime() + 0.001, msg)
def handleMessage(self, msg): assert msg is self.sendMessageEvent job = cMessage("job") self.send(job, "out") self.scheduleAt(simTime() + self.par("sendIaTime").doubleValue(), self.sendMessageEvent)
def initialize(self): self.iaTime = self.par("iaTime") self.numStations = self.par("numStations").intValue() self.myAddress = self.par("address").intValue() self.event = cMessage('event') # send self message to start activity self.scheduleAt(simTime() + self.iaTime.doubleValue(), self.event)
def initialize(self): self.myAddress = self.par("address").intValue() self.dim = self.par("dim").intValue() self.fromUserGateId = self.gate("fromGen").getId() self.total_usr = 0 self.discarded_usr = 0 self.event = cMessage('event') self.endOfSlot = cMessage("endOfSlot"); self.scheduleAt(simTime(), self.event)
def handleMessage(self, msg): if msg == self.endServiceMsg: self.endService(self.msgServiced) if self.queue.isEmpty(): self.msgServiced = None else: self.msgServiced = self.queue.pop() self.queueLength.record(self.queue.getLength()) serviceTime = self.startService(self.msgServiced) self.endServiceMsg.setSchedulingPriority(self.priority) self.scheduleAt(simTime() + serviceTime, self.endServiceMsg) elif self.msgServiced is None: self.arrival(msg) self.msgServiced = msg serviceTime = self.startService(self.msgServiced) self.endServiceMsg.setSchedulingPriority(self.priority) self.scheduleAt(simTime() + serviceTime, self.endServiceMsg) else: self.arrival(msg) self.queue.insert(msg) self.queueLength.record(self.queue.getLength())
def initialize(self): # Initialize variables. self.timeout = 1.0 self.timeoutEvent = cMessage("timoutEvent") # timeout self-message self.seq = 0 # message sequence number self.message = None # message that has to be re-sent on timeout # Generate and send initial message. EV << "Sending initial message\n" self.message = self.generateNewMessage() self.sendCopyOf(self.message) self.scheduleAt(simTime() + self.timeout, self.timeoutEvent)
def initialize(self): super().initialize() numInitialJobs = self.par("numInitialJobs").intValue() for i in range(numInitialJobs): job = cMessage("job") self.queue.insert(job) self.queueLength.record(self.queue.getLength()) if not self.queue.isEmpty(): self.msgServiced = self.queue.pop() self.queueLength.record(self.queue.getLength()) serviceTime = self.startService(self.msgServiced) self.scheduleAt(simTime() + serviceTime, self.endServiceMsg)
def refreshDisplay(self): t = (simTime() - self.lastStep) / self.timeStep assert 0 <= t <= 1 carTr = cFigure.Transform() carTr.rotate(self.heading + self.angularSpeed * t) distance = self.speed * t carTr.translate(self.loc.x + distance * math.cos(self.heading), self.loc.y + distance * math.sin(self.heading)) self.car.setTransform(carTr) antTr = cFigure.Transform() antTr.rotate(-2 * simTime().dbl() * math.pi / 180) self.antenna.setTransform(antTr) self.distanceDisplay.setText("{:.0f}".format(self.distanceTravelled)) degrees = -int(self.heading * 180 / math.pi) degrees = degrees - 360 * int(math.floor(degrees / 360)) self.headingDisplay.setText('{:.2f}°'.format(degrees))
def handleMessage(self, msg): if msg is self.timeoutEvent: # If we receive the timeout event, that means the packet hasn't # arrived in time and we have to re-send it. EV << "Timeout expired, resending message and restarting timer\n" self.sendCopyOf(self.message) self.scheduleAt(simTime() + self.timeout, self.timeoutEvent) else: # message arrived # Acknowledgement received! EV << "Received: " << msg.getName() << "\n" self.delete(msg) # Also delete the stored message and cancel the timeout event. EV << "Timer cancelled.\n" self.cancelEvent(self.timeoutEvent) self.delete(self.message) self.message = None # Ready to send another one. self.message = self.generateNewMessage() self.sendCopyOf(self.message) self.scheduleAt(simTime() + self.timeout, self.timeoutEvent)
def handleMessage(self, msg): if msg is self.event: # The self-message arrived, so we can send out tictocmsg and nullptr out # its pointer so that it doesn't confuse us later. EV << "Wait period is over, sending back message\n" self.send(self.tictocmsg, "out") self.tictocmsg = None else: # If the message we received is not our self-message, then it must be the tic-toc # message arriving from our partner. We remember its pointer in the tictocMsg variable, # then schedule our self-message to come back to us in 1s simulated time. EV << "Message arrived, starting to wait 1 sec...\n" self.tictocmsg = msg self.scheduleAt(simTime() + 1.0, self.event)
def __init__(self, *args, **kwargs): """Initialize all attributes as None.""" cSimpleModule.__init__(self, *args, **kwargs) self.timeStep = None # simtime_t self.lastStep = simTime() # simtime_t self.loc = None # Point self.speed = None # float self.heading = None # float self.angularSpeed = None # float self.targetPointIndex = None # int self.distanceTravelled = None # float self.road = None # cPolygonFigure self.car = None # cImageFigure self.antenna = None # cFigure self.trail = None # cPolylineFigure self.distanceDisplay = None # cTextFigure self.headingDisplay = None # cTextFigure
def handleMessage(self, msg): if msg is self.event: # The self-message arrived, so we can send out tictocmsg and nullptr out # its pointer so that it doesn't confuse us later. EV << "Wait period is over, sending back message\n" self.send(self.tictocmsg, "out") self.tictocmsg = None else: # "Lose" the message with 0.1 probability: if self.uniform(0, 1) < 0.1: EV << '"Losing" message\n' self.delete(msg) else: # The "delayTime" module parameter can be set to values like # "exponential(5)" (tictoc7.ned, omnetpp.ini), and then here # we'll get a different delay every time. delay = self.par("delayTime").doubleValue() EV << "Message arrived, starting to wait " << delay << " secs...\n" self.tictocmsg = msg self.scheduleAt(simTime() + delay, self.event)
def handleMessage(self, msg): EV << self.str() << " handleMessage\n" assert msg == self.endTxEvent self.getParentModule().getCanvas().setAnimationSpeed( self.transmissionEdgeAnimationSpeed, self) if self.state == self.IDLE: # generate packet and schedule timer when it ends self.pkCounter += 1 pkname = "pk-%d-#%d" % (self.getId(), self.pkCounter) EV << "generating packet " << pkname << '\n' self.state = self.TRANSMIT self.emit(self.stateSignal, self.state) pk = cPacket(pkname) pk.setBitLength(self.pkLenBits.intValue()) duration = pk.getBitLength() / self.txRate self.sendDirect(pk, self.radioDelay, duration, self.server.gate("in")) self.scheduleAt(simTime() + duration, self.endTxEvent) # let visualization code know about the new packet if self.transmissionRing is not None: self.delete(self.lastPacket) self.lastPacket = pk.dup() self.transmissionRing.setAssociatedObject(None) for c in self.transmissionCircles: c.setAssociatedObject(None) elif self.state == self.TRANSMIT: # endTxEvent indicates end of transmission self.state = self.IDLE self.emit(self.stateSignal, self.state) # schedule next sending self.scheduleAt(self.getNextTransmissionTime(), self.endTxEvent) else: raise RuntimeError("invalid state")
def handleMessage(self, msg): assert msg is self.event dest = self.intrand(self.numStations - 1) if dest >= self.myAddress: dest += 1 # create packet pkt = HCPacket('{}-->{}'.format(self.myAddress, dest)) pkt.srcAddress = self.myAddress pkt.destAddress = dest pkt.hops = 0 pkt.setTimestamp() EV << "Generated " << pkt.getName() << '\n' self.send(pkt, "out") # wait between messages # # Note that iaTime is a reference to the module parameter "iaTime" # that will be evaluated here. The module parameter can also take # a random value (for example: truncnormal(0.5,0.1) ). # send self message to start activity self.scheduleAt(simTime() + self.iaTime.doubleValue(), self.event)
def initialize(self): self.sendMessageEvent = cMessage("sendMessageEvent") self.scheduleAt(simTime(), self.sendMessageEvent)
def refreshDisplay(self): canvas = self.getParentModule().getCanvas() numCircles = 20 circleLineWidth = 10 # create figures on our first invocation if not self.transmissionRing: color = cFigure.GOOD_DARK_COLORS[self.getId() % cFigure.NUM_GOOD_DARK_COLORS] self.transmissionRing = cRingFigure("Host %d Ring" % self.getIndex()) self.transmissionRing.setOutlined(False) self.transmissionRing.setFillColor(color) self.transmissionRing.setFillOpacity(0.25) self.transmissionRing.setFilled(True) self.transmissionRing.setVisible(False) self.transmissionRing.setZIndex(-1) canvas.addFigure(self.transmissionRing) for i in range(numCircles): circle = cOvalFigure("Host %d Circle" % self.getIndex()) circle.setFilled(False) circle.setLineColor(color) circle.setLineOpacity(0.75) circle.setLineWidth(circleLineWidth) circle.setZoomLineWidth(True) circle.setVisible(False) circle.setZIndex(-0.5) self.transmissionCircles.append(circle) canvas.addFigure(circle) if self.lastPacket: # update transmission ring and circles if self.transmissionRing.getAssociatedObject() != self.lastPacket: self.transmissionRing.setAssociatedObject(self.lastPacket) for c in self.transmissionCircles: c.setAssociatedObject(self.lastPacket) now = simTime() frontTravelTime = now - self.lastPacket.getSendingTime() backTravelTime = now - (self.lastPacket.getSendingTime() + self.lastPacket.getDuration()) # conversion from time to distance in m using speed frontRadius = min(self.ringMaxRadius, frontTravelTime.dbl() * self.PROPAGATIONSPEED) backRadius = backTravelTime.dbl() * self.PROPAGATIONSPEED circleRadiusIncrement = self.circlesMaxRadius / numCircles # update transmission ring geometry and visibility/opacity opacity = 1.0 if backRadius > self.ringMaxRadius: self.transmissionRing.setVisible(False) self.transmissionRing.setAssociatedObject(None) else: self.transmissionRing.setVisible(True) self.transmissionRing.setBounds( cFigure.Rectangle(self.x - frontRadius, self.y - frontRadius, 2 * frontRadius, 2 * frontRadius)) self.transmissionRing.setInnerRadius( max(0.0, min(self.ringMaxRadius, backRadius))) if backRadius > 0: opacity = max(0.0, 1.0 - backRadius / self.circlesMaxRadius) self.transmissionRing.setLineOpacity(opacity) self.transmissionRing.setFillOpacity(opacity / 5) # update transmission circles geometry and visibility/opacity radius0 = (frontTravelTime.dbl() * self.PROPAGATIONSPEED) % circleRadiusIncrement for i, circle in enumerate(self.transmissionCircles): circleRadius = min(self.ringMaxRadius, radius0 + i * circleRadiusIncrement) if circleRadius < frontRadius - circleRadiusIncrement / 2 and circleRadius > backRadius + circleLineWidth / 2: circle.setVisible(True) circle.setBounds( cFigure.Rectangle(self.x - circleRadius, self.y - circleRadius, 2 * circleRadius, 2 * circleRadius)) circle.setLineOpacity( max(0.0, 0.2 - 0.2 * (circleRadius / self.circlesMaxRadius))) else: circle.setVisible(False) #/ compute animation speed animSpeed = self.idleAnimationSpeed if (frontRadius >= 0 and frontRadius < self.circlesMaxRadius) or ( backRadius >= 0 and backRadius < self.circlesMaxRadius): animSpeed = self.transmissionEdgeAnimationSpeed if frontRadius > self.circlesMaxRadius and backRadius < 0: animSpeed = self.midtransmissionAnimationSpeed canvas.setAnimationSpeed(animSpeed, self) else: # hide transmission rings, update animation speed if self.transmissionRing.getAssociatedObject() is not None: self.transmissionRing.setVisible(False) self.transmissionRing.setAssociatedObject(None) for c in self.transmissionCircles: c.setVisible(False) c.setAssociatedObject(None) canvas.setAnimationSpeed(self.idleAnimationSpeed, self) # update host appearance (color and text) self.getDisplayString().setTagArg("t", 2, "#808000") if self.state == self.IDLE: self.getDisplayString().setTagArg("i", 1, "") self.getDisplayString().setTagArg("t", 0, "") elif self.state == self.TRANSMIT: self.getDisplayString().setTagArg("i", 1, "yellow") self.getDisplayString().setTagArg("t", 0, "TRANSMIT")
def handleMessage(self, msg): if msg == self.event: # buffers for transit cells (rte) and for cells from local user (usr) self.rte_cell = [None] * 32 self.num_rte = 0; self.usr_cell = [None] * 32 self.num_usr = 0 # collect cells; user cells go into separate buffer self.scheduleAt(simTime() + SLOT_TIME, self.endOfSlot) elif msg is self.endOfSlot: # prepare arrays used in routing rte_dest = [-1] * 32 # destinations rte_port = [-1] * 32 # output ports usr_dest = [-1] * 32 usr_port = [-1] * 32 for i in range(self.num_rte): rte_dest[i] = self.rte_cell[i].destAddress for i in range(self.num_usr): usr_dest[i] = self.usr_cell[i].destAddress # make routing decision (function fills rte_port[] and usr_port[]) deflectionRouting( self.myAddress, self.dim, rte_dest, self.num_rte, rte_port, usr_dest, self.num_usr, usr_port); # send out transit cells for i in range(self.num_rte): self.rte_cell[i].hops = self.rte_cell[i].hops + 1 self.sendDelayed(self.rte_cell[i], PROPDEL, "out", rte_port[i]) # send out user cells for i in range(self.num_usr): if usr_port[i] < 0: self.discarded_usr += 1 self.delete(self.usr_cell[i]) self.usr_cell[i] = None else: self.usr_cell[i].hops = self.usr_cell[i].hops + 1 self.sendDelayed(self.usr_cell[i], PROPDEL, "out", usr_port[i]) EV << "rte[" << self.myAddress << "]: Discarded " \ << self.discarded_usr << " out of " << self.total_usr << "\n" # to begin again self.scheduleAt(simTime(), self.event) else: # it is a packet pkt = msg if pkt.getArrivalGateId() != self.fromUserGateId: if pkt.destAddress != self.myAddress: self.rte_cell[self.num_rte] = pkt self.num_rte += 1 else: self.send(pkt, "toSink") else: self.total_usr += 1 if self.num_usr < 32: self.usr_cell[self.num_usr] = pkt self.num_usr += 1 else: self.discarded_usr += 1 self.delete(pkt)