def pong_handler(event, source=None):
cmd = Message('PING', next(pyons.get_model().command_index))
pyons.get_model().num_pings_generated += 1
pyons.create_timeout(pyons.get_model().next_ping_timeout, cmd)
pyons.info("received {}, sending {} in {} sec.".format(
event, cmd, pyons.get_model().next_ping_timeout),
sender="pong_handler")
def _initialize_vehicle(self):
vrec = journal.VehicleInfoRecord()
vrec.vehicle_id = self.vehicle_id
vrec.created_at = pyons.time()
vrec.destroyed_at = None
vrec.direction = self.direction
vrec.lane = self.lane
vrec.speed = self.speed
vrec.n_read = 0
journal.Journal().write_vehicle_created(vrec)
self._created_at = pyons.time()
if self.front_tag is not None:
self.front_tag.vehicle = self
vrec.front_tag_epc = self.front_tag.epc
vrec.front_tag_tid = self.front_tag.tid
pyons.get_model().add_tag(self.front_tag)
if self.back_tag is not None:
self.back_tag.vehicle = self
vrec.back_tag_epc = self.back_tag.epc
vrec.back_tag_tid = self.back_tag.tid
pyons.get_model().add_tag(self.back_tag)
pyons.debug(
f"created vehicle {self.vehicle_id} with "
f"front tag epc={self.front_tag.epc if self.front_tag else '-'}, "
f"back tag epc={self.back_tag.epc if self.back_tag else '-'}")
def finalize():
m = pyons.get_model()
pyons.info("PingPong is finished:", sender="finalize")
print("\t+ pings generated: {}".format(m.num_pings_generated))
print("\t+ pongs generated: {}".format(m.num_pongs_generated))
print("\t+ events generated: {}".format(pyons.get_num_events_served()))
events = ['{}@t={}'.format(envelope.event, envelope.time)
for envelope in pyons.Dispatcher().events]
print("\t+ resting events: {}".format(events))
def _handle_generate_vehicle(self, event, source):
msg, lane = event
assert source is self and msg == 'generate vehicle'
model = pyons.get_model()
vehicle = Factory().build_vehicle(lane, model.channel)
model.add_vehicle(vehicle)
pyons.create_timeout(self.params.vehicle_generation_interval(),
('generate vehicle', lane))
self.n_generated += 1
if self.n_generated % 10 == 0:
print("{:4.1f} [GENERATOR] created {} vehicles".format(
systime.time() - self.t_started, self.n_generated))
def handle_update_position(event, source):
assert event == UPDATE_POSITION_EVENT and source is None
model = pyons.get_model()
for tag in model.tags:
assert isinstance(tag, Tag)
tag.update_position()
tag.update_received_power()
j = journal.Journal()
if j.channel_state_logging_enabled:
rec = build_channel_state_record(model.reader, tag, model.channel)
j.write_channel_state(rec)
pyons.create_timeout(model.position_update_interval, UPDATE_POSITION_EVENT)
def _handle_ack_reply(self, reply):
epc = (reply.epc if isinstance(reply.epc, str) else "".join(
[format(x, '02X') for x in reply.epc]))
assert isinstance(self.tag_read_data, journal.TagReadRecord)
tag = pyons.get_model().get_tag(epc)
self.tag_read_data.epc = epc
self.tag_read_data.vehicle_lane = tag.lane
self.tag_read_data.location = tag.location
if self.read_tid:
self._send(gen2.ReqRn(rn=self._rn))
else:
self._handle_slot_end()
def _vehicle_finalizer(self):
t = pyons.time()
journal.Journal().write_vehicle_destroyed(self.vehicle_id, t)
if self.front_tag is not None:
pyons.get_model().remove_tag(self.front_tag)
if self.back_tag is not None:
pyons.get_model().remove_tag(self.back_tag)
pyons.get_model().remove_vehicle(self)
pyons.debug(f"removed vehicle {self.vehicle_id}")
def check_generated_enough():
return pyons.get_model().num_pongs_generated >= 300
def ping_handler(event, source=None):
reply = Message('PONG', event.index)
pyons.get_model().num_pongs_generated += 1
pyons.create_timeout(pyons.get_model().reply_timeout, reply)
pyons.info("received {}, sending {} in {} sec.".format(
event, reply, pyons.get_model().reply_timeout), sender="ping_handler")
def initialize():
pyons.info("PingPong is initializing", sender="initialize")
cmd = Message('PING', next(pyons.get_model().command_index))
pyons.get_model().num_pings_generated += 1
pyons.create_timeout(0, cmd)
def _handle_round_start(self):
if not self.is_powered_on:
raise RuntimeError("round start during power-off")
self._round_index += 1
self._slot = 0
#
# Switching antenna if needed
#
if self.rounds_per_antenna is not None and (
self._round_index % self.rounds_per_antenna == 0):
n_antennas = len(self.antennas)
self._antenna_index = (self._antenna_index + 1) % n_antennas
#
# Switching inventory flag if needed
#
if self.session_strategy == Reader.SessionStrategy.ALTER:
if (self.rounds_per_inventory_flag is not None) and \
(self._round_index % self.rounds_per_inventory_flag == 0):
self._inventory_flag = self._inventory_flag.invert()
# pyons.fine(("\n\t*---------- NEW ROUND ------------*"
# "\n\t* round index : {round_index}"
# "\n\t* antenna index: {antenna_index}"
# "\n\t* Q : {q}"
# "\n\t* session : {session}"
# "\n\t* target : {target}").format(
# round_index=self._round_index, antenna_index=self._antenna_index,
# q=self.q, session=self.session, target=self._inventory_flag),
# sender=self.name)
for transceiver in self.channel.passive_transceivers:
transceiver.node.update_position()
transceiver.node.update_received_power()
#
# Refresh statistics
#
# STATISTICS ====>
self.tag_read_data = self._create_tag_read_data()
self.round_info = self._create_round_info()
self._slot_durations = []
self._slot_started_at = pyons.time()
self._round_started_at = pyons.time()
model = pyons.get_model()
self.round_info.n_tags = len(
[tag for tag in model.tags if tag.energized])
self.round_info.n_vehicles_registered = len(model.vehicles)
self.round_info.antenna_index = self._antenna_index
# <===== END OF STATISTICS
#
# Generating and sending Query
#
query = gen2.Query(dr=self.dr,
m=self.m,
trext=self.trext,
sel=self.sl,
session=self.session,
target=self._inventory_flag,
q=self.q)
self._send(query)
def init_mobility_manager():
model = pyons.get_model()
pyons.create_timeout(model.position_update_interval, UPDATE_POSITION_EVENT)
