def initialize(self):
self.event = cMessage('event')
self.tictocmsg = None
if self.getName() == 'tic':
EV << "Scheduling first send to t=5.0s\n"
self.tictocmsg = cMessage("tictocmsg")
self.scheduleAt(5.0, 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 initialize(self):
self.counter = 10
WATCH('counter', self)
if self.getName() == 'tic':
EV << 'Sending initial message\n'
msg = cMessage("pymessage")
self.send(msg, "out")
def initialize(self):
self.counter = self.par('limit').intValue()
WATCH('counter', self)
if self.par('sendMsgOnInit').boolValue():
EV << 'Sending initial message\n'
msg = cMessage("pymessage")
self.send(msg, "out")
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 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 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.endServiceMsg = cMessage("end-service")
self.queue.setName("queue")
self.qlenSignal = self.registerSignal("qlen")
self.busySignal = self.registerSignal("busy")
self.queueingTimeSignal = self.registerSignal("queueingTime")
self.emit(self.qlenSignal, self.queue.getLength())
self.emit(self.busySignal, False)
def handleMessage(self, msg):
if self.uniform(0, 1) < 0.1:
EV << '"Losing" message ' << msg.getName() << '\n'
self.bubble("message lost")
self.delete(msg)
else:
EV << msg.getName(
) << " received, sending back an acknowledgement.\n"
self.delete(msg)
self.send(cMessage("ack"), "out")
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 initialize(self):
self.stateSignal = self.registerSignal("state")
self.server = self.getModuleByPath("server")
if not self.server:
raise RuntimeError("server not found")
self.txRate = self.par("txRate").doubleValue()
# TODO
self.iaTime = self.par("iaTime")
self.pkLenBits = self.par("pkLenBits")
self.slotTime = self.par("slotTime").doubleValue()
self.isSlotted = self.slotTime > 0
WATCH('slotTime')
WATCH('isSlotted')
self.endTxEvent = cMessage("send/endTx")
self.state = self.IDLE
self.emit(self.stateSignal, self.state)
self.pkCounter = 0
WATCH('state')
WATCH('pkCounter')
self.x = self.par("x").doubleValue()
self.y = self.par("y").doubleValue()
serverX = self.server.par("x").doubleValue()
serverY = self.server.par("y").doubleValue()
self.idleAnimationSpeed = self.par("idleAnimationSpeed").doubleValue()
self.transmissionEdgeAnimationSpeed = self.par(
"transmissionEdgeAnimationSpeed").doubleValue()
self.midtransmissionAnimationSpeed = self.par(
"midTransmissionAnimationSpeed").doubleValue()
dist = math.sqrt((self.x - serverX)**2 + (self.y - serverY)**2)
self.radioDelay = dist / self.PROPAGATIONSPEED
self.getDisplayString().setTagArg("p", 0, self.x)
self.getDisplayString().setTagArg("p", 1, self.y)
self.scheduleAt(self.getNextTransmissionTime(), self.endTxEvent)
def initialize(self):
self.valuesVector.setName("values")
self.weightsVector.setName("weights")
self.count = self.par("count").intValue()
self.weighted = self.par("weighted").boolValue()
self.createStatisticObjects()
self.unweightedValueSignal = self.registerSignal("unweightedValue")
EV << "Created " << len(
self.statisticObjects) << " statistics objects.\n\n"
EV << (
"If Qtenv is used (it is the default), you may click the Children mode\n"
"button of the object inspector, and double-click the items to open\n"
"graphical inspectors for the distributions.\n\n")
EV << "Collecting variables from: " << self.par(
"variable").str() << "\n"
self.scheduleAt(0, cMessage())
def initialize(self):
if self.getName() == 'tic':
msg = cMessage("pymessage")
self.send(msg, "out")
def initialize(self):
# build the network in event 1, because it is undefined whether the simkernel
# will implicitly initialize modules created *during* initialization, or this needs
# to be done manually.
self.scheduleAt(0, cMessage())
def initialize(self):
if self.getIndex() == 0:
# Boot the process scheduling the initial message as a self-message.
self.scheduleAt(0.0, cMessage('tic-0'))
def initialize(self):
if self.getName() == 'tic':
EV << 'Sending initial message\n'
msg = cMessage("pymessage")
self.send(msg, "out")
def generateNewMessage(self):
# Generate a message with a different name every time.
self.seq += 1
return cMessage('tic-{:02d}'.format(self.seq))
def initialize(self):
self.sendMessageEvent = cMessage("sendMessageEvent")
self.scheduleAt(simTime(), self.sendMessageEvent)
def initialize(self):
self.priority = self.par("priority").intValue()
self.endServiceMsg = cMessage("end-service")
self.queue = cQueue("queue")
self.queueLength = cOutVector("queueLength")
