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)