def get_carry_schedules(vehicle_id, user_id, carry_route, current_time):
targets = [
Target.new_target(vehicle_id, SIM_TAXI.NODE_NAME),
Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME)
]
move_for_discharging_schedules = Schedule.new_schedule(
targets, SIM_TAXI.TRIGGER.MOVE, current_time, current_time + 1010,
carry_route)
stop_for_discharging_schedules = Schedule.new_schedule(
targets, SIM_TAXI.TRIGGER.STOP, current_time + 1010,
current_time + 1020,
Route.new_point_route(carry_route.goal_waypoint_id,
carry_route.arrow_codes[-1]))
move_schedule = Schedule.new_schedule(
targets, SIM_TAXI_USER.TRIGGER.MOVE_VEHICLE, current_time,
current_time + 1010, carry_route)
getting_out_schedule = Schedule.new_schedule(
targets, SIM_TAXI_USER.TRIGGER.GET_OUT, current_time + 1010,
current_time + 1020,
Route.new_point_route(carry_route.goal_waypoint_id,
carry_route.arrow_codes[-1]))
got_out_schedule = Schedule.new_schedule(
[Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME)],
SIM_TAXI_USER.TRIGGER.GOT_OUT, current_time + 1020,
current_time + 1021,
Route.new_point_route(carry_route.goal_waypoint_id,
carry_route.arrow_codes[-1]))
log_out_schedule = Schedule.new_schedule(
[Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME)],
USER.TRIGGER.LOG_OUT, current_time + 1021, current_time + 1022,
Route.new_point_route(carry_route.goal_waypoint_id,
carry_route.arrow_codes[-1]))
return [move_for_discharging_schedules, stop_for_discharging_schedules],\
[move_schedule, getting_out_schedule, got_out_schedule, log_out_schedule]
def set_bus_schedules(self, bus_schedules):
self.__bus_schedules = bus_schedules
for bus_schedules_id in self.__bus_schedules:
self.relation.add_relation(
Target.new_target(bus_schedules_id,
SIM_BUS_FLEET.TARGET_GROUP.BUS_SCHEDULES),
Target.new_target(None, SIM_BUS.NODE_NAME))
def get_pickup_schedules(vehicle_id, user_id, pickup_route, current_time):
targets = [
Target.new_target(vehicle_id, SIM_TAXI.NODE_NAME),
Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME)
]
move_for_picking_up_schedule = Schedule.new_schedule(
targets, SIM_TAXI.TRIGGER.MOVE, current_time, current_time + 1000,
pickup_route)
stop_for_picking_up_schedule = Schedule.new_schedule(
targets, SIM_TAXI.TRIGGER.STOP, current_time + 1000,
current_time + 1010,
Route.new_point_route(pickup_route.goal_waypoint_id,
pickup_route.arrow_codes[-1]))
waiting_schedule = Schedule.new_schedule(
targets, SIM_TAXI_USER.TRIGGER.WAIT, current_time,
current_time + 1000,
Route.new_point_route(pickup_route.goal_waypoint_id,
pickup_route.arrow_codes[-1]))
getting_on_schedule = Schedule.new_schedule(
targets, SIM_TAXI_USER.TRIGGER.GET_ON, current_time + 1000,
current_time + 1010,
Route.new_point_route(pickup_route.goal_waypoint_id,
pickup_route.arrow_codes[-1]))
got_on_schedule = Schedule.new_schedule(
targets, SIM_TAXI_USER.TRIGGER.GOT_ON, current_time + 1010,
current_time + 1011,
Route.new_point_route(pickup_route.goal_waypoint_id,
pickup_route.arrow_codes[-1]))
return [move_for_picking_up_schedule, stop_for_picking_up_schedule],\
[waiting_schedule, getting_on_schedule, got_on_schedule]
def __init__(self, _id):
self.manager = Manager()
self.event_loop_id = _id
self.target = Target.new_target(self.event_loop_id,
self.__class__.__name__)
self.__subscribers = {}
self.__subscribers_lock = self.manager.Lock()
self.__publishers = {}
self.__client = None
self.__main_loop = None
self.__pid = os.getpid()
self.__topicPub = Topic()
self.__topicPub.set_targets(
Target.new_target(self.event_loop_id, EventLoop.__name__))
self.__topicPub.set_categories(EVENT_LOOP.TOPIC.CATEGORIES.RESPONSE)
self.__topicSub = Topic()
self.__topicSub.set_targets(
None, Target.new_target(self.event_loop_id, EventLoop.__name__))
self.__topicSub.set_categories(EVENT_LOOP.TOPIC.CATEGORIES.REQUEST)
self.__topicSub.set_message(EventLoopMessage)
self.set_subscriber(self.__topicSub, self.on_event_loop_message)
self.__user_data = None
self.__user_will = None
def __init__(self,
_id,
name,
waypoint,
arrow,
route,
intersection,
dt=1.0):
super().__init__(_id,
name,
waypoint,
arrow,
route,
intersection,
dt=dt)
self.state_machine = self.get_state_machine()
self.user_statuses = self.manager.dict()
self.user_statuses_lock = self.manager.Lock()
self.__topicSubUserStatus = Topic()
self.__topicSubUserStatus.set_targets(
Target.new_target(None, SIM_BUS_USER.NODE_NAME), None)
self.__topicSubUserStatus.set_categories(USER.TOPIC.CATEGORIES.STATUS)
self.__topicSubUserStatus.set_message(UserStatus)
self.set_subscriber(self.__topicSubUserStatus, self.update_user_status)
def __init__(self, _id, name, waypoint, arrow, route, dt=3.0):
super().__init__(_id)
self.status = FleetStatus.new_data(name=name,
time=time(),
state=FLEET_MANAGER.STATE.LOG_IN,
relations={})
self.waypoint = waypoint
self.arrow = arrow
self.route = route
self.relation = Relation()
self.traffic_signals = self.manager.dict()
self.state_machine = None
self.dt = dt
self.__pubTopicStatus = Topic()
self.__pubTopicStatus.set_targets(self.target)
self.__pubTopicStatus.set_categories(
FLEET_MANAGER.TOPIC.CATEGORIES.STATUS)
self.__topicSubTrafficSignalStatus = Topic()
self.__topicSubTrafficSignalStatus.set_targets(
Target.new_target(None, TRAFFIC_SIGNAL.NODE_NAME), None)
self.__topicSubTrafficSignalStatus.set_categories(
TRAFFIC_SIGNAL.TOPIC.CATEGORIES.STATUS)
self.__topicSubTrafficSignalStatus.set_message(TrafficSignalStatus)
self.set_subscriber(self.__topicSubTrafficSignalStatus,
self.update_traffic_signal_status)
self.set_main_loop(self.__main_loop)
def after_change_state_publish_new_bus_schedules(self, current_time,
vehicle_id):
target_vehicle = Target.new_target(vehicle_id, SIM_BUS.NODE_NAME)
target_bus_schedule = self.get_unassigned_bus_schedule_target()
vehicle_schedules = []
start_time = current_time
move_to_circular_route_schedule, branch_index, part_type, part_index = \
self.get_move_to_circular_route_schedule(
target_vehicle, target_bus_schedule, start_time)
vehicle_schedules = \
Schedule.get_merged_schedules(vehicle_schedules, [move_to_circular_route_schedule])
start_time = vehicle_schedules[-1].period.end
move_to_branch_point_schedules, branch_index, part_type, part_index = \
self.get_move_to_branch_point_schedules(
target_vehicle, target_bus_schedule, start_time, branch_index, part_type, part_index)
vehicle_schedules = \
Schedule.get_merged_schedules(vehicle_schedules, move_to_branch_point_schedules)
self.vehicle_schedules[vehicle_id][0].period.end = current_time
self.vehicle_schedules[vehicle_id] = \
Schedule.get_merged_schedules(self.vehicle_schedules[vehicle_id], vehicle_schedules)
self.update_relation(target_bus_schedule, vehicle_id)
self.after_change_state_update_last_indices(vehicle_id, branch_index,
part_type, part_index)
self.after_change_state_publish_schedules(vehicle_id)
return True
def __init__(self, _id, name, waypoint, arrow, route, spot):
super().__init__(_id, name, waypoint, arrow, route)
self.waypoint = waypoint
self.arrow = arrow
self.route = route
self.spot = spot
self.relation = Relation()
self.__bus_routes = {}
self.__bus_schedules = {}
self.bus_parkable_spots = self.spot.get_spots_of_target_group(
Target.new_node_target(SimBus))
self.vehicle_statuses = self.manager.dict()
self.vehicle_statuses_lock = self.manager.Lock()
self.vehicle_schedules = {}
self.vehicle_last_indices = {}
self.bus_schedules = {}
self.bus_stop_spots = {}
self.state_machines = {}
self.__topicPubVehicleSchedules = Topic()
self.__topicPubVehicleSchedules.set_categories(
FleetManager.CONST.TOPIC.CATEGORIES.SCHEDULES)
self.__topicSubVehicleStatus = Topic()
self.__topicSubVehicleStatus.set_targets(
Target.new_target(None, SIM_BUS.NODE_NAME), None)
self.__topicSubVehicleStatus.set_categories(
Vehicle.CONST.TOPIC.CATEGORIES.STATUS)
self.__topicSubVehicleStatus.set_message(VehicleStatus)
self.set_subscriber(self.__topicSubVehicleStatus,
self.update_vehicle_status)
def get_unassigned_bus_schedule_target(self):
targets = Target.new_targets(
self.relation.get_related(
Target.new_target(None, SIM_BUS.NODE_NAME)))
if len(targets) == 0:
return None
return targets[0]
def get_deploy_schedules(vehicle_id, carry_route, current_time):
stand_by_schedules = Schedule.new_schedule(
[
Target.new_target(vehicle_id, SIM_TAXI.NODE_NAME),
], SIM_TAXI.TRIGGER.STAND_BY, current_time, current_time + 86400,
Route.new_point_route(carry_route.goal_waypoint_id,
carry_route.arrow_codes[-1]))
return [stand_by_schedules]
def get_user_request_schedules(self, user_id, current_time):
user_request_schedule = Schedule.new_schedule(
[Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME)],
SIM_TAXI_USER.TRIGGER.REQUEST,
current_time,
current_time + 1,
)
user_schedules = Schedule.get_merged_schedules(
self.user_schedules[user_id], [user_request_schedule])
return user_schedules
def cleanup_status(self, user_statuses):
user_ids = []
for user_id, user_status in user_statuses.items():
if SIM_TAXI_FLEET.TIMEOUT < time() - user_status.time:
user_ids.append(user_id)
for user_id in user_ids:
self.relation.remove_relations_of(
Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME))
user_statuses.pop(user_id)
self.user_schedules.pop(user_id)
def get_response_path(self, request_path):
path = "/" + self.domain
path += Topic.get_target_path_part(self.from_target)
path += Topic.get_target_path_part(
Target.new_target(*list(reversed(request_path.split("/")[2:4]))))
path += "/" + "/".join(
self.categories if self.categories is not None else "#")
return path
def __init__(self,
_id,
name,
waypoint,
arrow,
route,
intersection,
dt=1.0):
super().__init__(_id, name, waypoint, arrow, route, dt=dt)
self.state_machine = self.get_state_machine()
self.velocity = None
self.traffic_signals = self.manager.dict()
self.traffic_signals_lock = self.manager.Lock()
self.other_vehicle_locations = self.manager.dict()
self.other_vehicle_locations_lock = self.manager.Lock()
self.intersection = intersection
self.__topicPubLocation = Topic()
self.__topicPubLocation.set_targets(
Target.new_target(self.target.id, SIM_CAR.NODE_NAME))
self.__topicPubLocation.set_categories(
SIM_CAR.TOPIC.CATEGORIES.LOCATION)
self.__topicSubStatus = Topic()
self.__topicSubStatus.set_targets(
Target.new_target(None, SIM_CAR.NODE_NAME), None)
self.__topicSubStatus.set_categories(SIM_CAR.TOPIC.CATEGORIES.LOCATION)
self.__topicSubStatus.set_message(Location)
self.set_subscriber(self.__topicSubStatus,
self.update_other_vehicle_locations)
self.__topicSubTrafficSignalStatus = Topic()
self.__topicSubTrafficSignalStatus.set_targets(
Target.new_target(None, TRAFFIC_SIGNAL.NODE_NAME), None)
self.__topicSubTrafficSignalStatus.set_categories(
TRAFFIC_SIGNAL.TOPIC.CATEGORIES.STATUS)
self.__topicSubTrafficSignalStatus.set_message(TrafficSignalStatus)
self.set_subscriber(self.__topicSubTrafficSignalStatus,
self.update_traffic_signals)
def after_state_change_update_schedule_target(vehicle_id, schedules):
for i, schedule in enumerate(schedules):
if schedule.event in [
SIM_BUS_USER.TRIGGER.GOT_ON,
SIM_BUS_USER.TRIGGER.MOVE_VEHICLE,
SIM_BUS_USER.TRIGGER.REQUEST_STOP,
SIM_BUS_USER.TRIGGER.GET_OUT,
SIM_BUS_USER.TRIGGER.GOT_OUT,
]:
schedules[i].targets.append(
Target.new_target(vehicle_id, SIM_BUS.NODE_NAME))
return True
def __init__(self, _id, name, waypoint, arrow, route):
super().__init__(_id, name, waypoint, arrow, route)
self.waypoint = waypoint
self.arrow = arrow
self.route = route
self.user_statuses = self.manager.dict()
self.user_statuses_lock = self.manager.Lock()
self.vehicle_statuses = self.manager.dict()
self.vehicle_statuses_lock = self.manager.Lock()
self.user_schedules = {}
self.vehicle_schedules = {}
self.state_machines = {}
self.__topicPubUserSchedules = Topic()
self.__topicPubUserSchedules.set_categories(
FLEET_MANAGER.TOPIC.CATEGORIES.SCHEDULES)
self.__topicPubVehicleSchedules = Topic()
self.__topicPubVehicleSchedules.set_categories(
FLEET_MANAGER.TOPIC.CATEGORIES.SCHEDULES)
self.__topicSubUserStatus = Topic()
self.__topicSubUserStatus.set_targets(
Target.new_target(None, SIM_TAXI_USER.NODE_NAME), None)
self.__topicSubUserStatus.set_categories(USER.TOPIC.CATEGORIES.STATUS)
self.__topicSubUserStatus.set_message(UserStatus)
self.set_subscriber(self.__topicSubUserStatus, self.update_user_status)
self.__topicSubVehicleStatus = Topic()
self.__topicSubVehicleStatus.set_targets(
Target.new_target(None, SIM_TAXI.NODE_NAME), None)
self.__topicSubVehicleStatus.set_categories(
VEHICLE.TOPIC.CATEGORIES.STATUS)
self.__topicSubVehicleStatus.set_message(VehicleStatus)
self.set_subscriber(self.__topicSubVehicleStatus,
self.update_vehicle_status)
def after_change_state_publish_through_schedules(self, vehicle_id):
target_vehicle = Target.new_target(vehicle_id, SIM_BUS.NODE_NAME)
target_bus_schedule = self.get_assigned_bus_schedule_target(
target_vehicle)
move_to_branch_point_schedules, branch_index, part_type, part_index = \
self.get_move_to_branch_point_schedules(
target_vehicle, target_bus_schedule, self.vehicle_schedules[vehicle_id][-1].period.end,
self.vehicle_last_indices[vehicle_id]["branch_index"], "main", 0)
self.vehicle_schedules[vehicle_id] = Schedule.get_merged_schedules(
self.vehicle_schedules[vehicle_id], move_to_branch_point_schedules)
self.after_change_state_update_last_indices(vehicle_id, branch_index,
part_type, part_index)
self.after_change_state_publish_schedules(vehicle_id)
return True
def __init__(self, _id, name, dt=1.0):
super().__init__(_id, name, dt)
self.state_machine = self.get_state_machine()
self.target_start_bus_stop = None
self.target_goal_bus_stop = None
self.vehicle_id = None
self.vehicle_statuses = self.manager.dict()
self.vehicle_statuses_lock = self.manager.Lock()
self.__topicSubVehicleStatus = Topic()
self.__topicSubVehicleStatus.set_targets(
Target.new_target(None, SIM_BUS.NODE_NAME), None)
self.__topicSubVehicleStatus.set_categories(
VEHICLE.TOPIC.CATEGORIES.STATUS)
self.__topicSubVehicleStatus.set_message(VehicleStatus)
self.set_subscriber(self.__topicSubVehicleStatus,
self.update_vehicle_status)
def __init__(self, _id, name, waypoint, arrow, route, dt=0.5):
super().__init__(_id, name, waypoint, arrow, route, dt=dt)
self.upper_distance_from_stopline = AUTOWARE.DEFAULT_UPPER_DISTANCE_FROM_STOPLINE
self.state_machine = self.get_state_machine()
self.__map_match = MapMatch()
self.__map_match.set_waypoint(self.waypoint)
self.__map_match.set_arrow(self.arrow)
self.ros_closest_waypoint = None
self.ros_closest_waypoint_lock = self.manager.Lock()
self.ros_current_pose = None
self.ros_current_pose_lock = self.manager.Lock()
self.ros_decisionmaker_states = None
self.ros_decisionmaker_states_lock = self.manager.Lock()
self.current_locations = []
self.traffic_signals = self.manager.dict()
self.traffic_signals_lock = self.manager.Lock()
self.__previous_state_command = None
self.__topicPubBasedLaneWaypointsArray = Topic()
self.__topicPubBasedLaneWaypointsArray.set_targets(
self.target, Target.new_target(self.target.id, AUTOWARE.TOPIC.ROS_NODE_NAME))
self.__topicPubBasedLaneWaypointsArray.set_categories(AUTOWARE.TOPIC.CATEGORIES.BASED_LANE_WAYPOINTS_ARRAY)
self.__topicPubStateCmd = Topic()
self.__topicPubStateCmd.set_targets(
self.target, Target.new_target(self.target.id, AUTOWARE.TOPIC.ROS_NODE_NAME))
self.__topicPubStateCmd.set_categories(AUTOWARE.TOPIC.CATEGORIES.STATE_CMD)
self.__topicPubLightColor = Topic()
self.__topicPubLightColor.set_targets(
self.target, Target.new_target(self.target.id, AUTOWARE.TOPIC.ROS_NODE_NAME))
self.__topicPubLightColor.set_categories(AUTOWARE.TOPIC.CATEGORIES.LIGHT_COLOR)
self.__topicSubCurrentPose = Topic()
self.__topicSubCurrentPose.set_targets(
Target.new_target(self.target.id, AUTOWARE.TOPIC.ROS_NODE_NAME), self.target)
self.__topicSubCurrentPose.set_categories(AUTOWARE.TOPIC.CATEGORIES.CURRENT_POSE)
self.__topicSubCurrentPose.set_message(ROSMessage.CurrentPose)
self.set_subscriber(self.__topicSubCurrentPose, self.update_current_pose)
self.__topicSubClosestWaypoint = Topic()
self.__topicSubClosestWaypoint.set_targets(
Target.new_target(self.target.id, AUTOWARE.TOPIC.ROS_NODE_NAME), self.target)
self.__topicSubClosestWaypoint.set_categories(AUTOWARE.TOPIC.CATEGORIES.CLOSEST_WAYPOINT)
self.__topicSubClosestWaypoint.set_message(ROSMessage.ClosestWaypoint)
self.set_subscriber(self.__topicSubClosestWaypoint, self.update_closest_waypoint)
self.__topicSubDecisionMakerStates = Topic()
self.__topicSubDecisionMakerStates.set_targets(
Target.new_target(self.target.id, AUTOWARE.TOPIC.ROS_NODE_NAME), self.target)
self.__topicSubDecisionMakerStates.set_categories(AUTOWARE.TOPIC.CATEGORIES.DECISION_MAKER_STATES)
self.__topicSubDecisionMakerStates.set_message(ROSMessage.DecisionMakerStates)
self.set_subscriber(self.__topicSubDecisionMakerStates, self.update_decisionmaker_states)
self.__topicSubTrafficSignalStatus = Topic()
self.__topicSubTrafficSignalStatus.set_targets(Target.new_target(None, TRAFFIC_SIGNAL.NODE_NAME))
self.__topicSubTrafficSignalStatus.set_categories(TRAFFIC_SIGNAL.TOPIC.CATEGORIES.STATUS)
self.__topicSubTrafficSignalStatus.set_message(TrafficSignalStatus)
self.set_subscriber(self.__topicSubTrafficSignalStatus, self.update_traffic_signals)
def after_state_change_add_relation(self, user_id, vehicle_id):
self.relation.add_relation(
Target.new_target(vehicle_id, SIM_TAXI.NODE_NAME),
Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME))
return True
def update_relation(self, target_bus_schedule, vehicle_id):
self.relation.remove_relation(
target_bus_schedule, Target.new_target(None, SIM_BUS.NODE_NAME))
self.relation.add_relation(
target_bus_schedule,
Target.new_target(vehicle_id, SIM_BUS.NODE_NAME))
eventlet.monkey_patch()
app = Flask(__name__)
with app.app_context():
app.waypoint = Waypoint()
app.waypoint.load(args.path_waypoint_json)
app.arrow = Arrow()
app.arrow.load(args.path_arrow_json)
app.intersection = Intersection()
app.intersection.load(args.path_intersection_json)
app.topics = {}
topic = Topic()
topic.set_targets(Target.new_target(None, Autoware.CONST.NODE_NAME), None)
topic.set_categories(Vehicle.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["vehicle"] = topic.get_path(use_wild_card=True)
topic = Topic()
topic.set_targets(Target.new_target(None, TrafficSignal.CONST.NODE_NAME),
None)
topic.set_categories(TrafficSignal.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["traffic_signal"] = topic.get_path(use_wild_card=True)
pp(app.topics)
CORS(app)
app.config['MQTT_BROKER_URL'] = env["MQTT_BROKER_HOST"]
app.config['MQTT_BROKER_PORT'] = int(env["MQTT_BROKER_PORT"])
def __publish_vehicle_schedules(self, vehicle_id, payload):
self.__topicPubVehicleSchedules.set_targets(
self.target, Target.new_target(vehicle_id, SIM_BUS.NODE_NAME))
self.publish(self.__topicPubVehicleSchedules, payload)
def update_state_machines(self, user_statuses, vehicle_statuses):
current_time = time()
remove_user_ids = []
for user_id in user_statuses:
if user_id not in self.state_machines:
self.state_machines[user_id] = self.get_state_machine()
user_status = user_statuses[user_id]
target_vehicles = self.relation.get_related(
Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME))
state = self.state_machines[user_id].state
if len(target_vehicles) == 0:
if state == SIM_TAXI_FLEET.STATE.WAITING_FOR_USER_LOG_IN:
self.state_machines[user_id].wait_user_request(
user_id, user_status, USER.STATE.LOG_IN, current_time)
elif state == SIM_TAXI_FLEET.STATE.WAITING_FOR_USER_REQUEST:
self.state_machines[user_id].dispatch(
user_id, user_status, SIM_TAXI_USER.STATE.CALLING,
current_time)
elif len(target_vehicles) == 1:
vehicle_id = target_vehicles[0].id
if user_id in map(
lambda x: x.id,
self.vehicle_schedules[vehicle_id][0].targets):
vehicle_status = vehicle_statuses[vehicle_id]
if state == SIM_TAXI_FLEET.STATE.WAITING_FOR_TAXI_ARRIVE_AT_USER_LOCATION:
self.state_machines[user_id].notice(
user_id, user_status, vehicle_status, [
SIM_TAXI_USER.STATE.WAITING,
SIM_TAXI.STATE.STOP_FOR_PICKING_UP
], current_time)
elif state == SIM_TAXI_FLEET.STATE.WAITING_FOR_USER_GETTING_ON:
self.state_machines[user_id].wait_taxi_arrival(
user_id, user_status, SIM_TAXI_USER.STATE.GOT_ON,
vehicle_id, current_time)
elif state == SIM_TAXI_FLEET.STATE.WAITING_FOR_TAXI_ARRIVE_AT_USER_DESTINATION:
self.state_machines[user_id].notice(
user_id, user_status, vehicle_status, [
SIM_TAXI_USER.STATE.MOVING,
SIM_TAXI.STATE.STOP_FOR_DISCHARGING
], current_time)
else:
pass
else:
logger.error(
pformat({"target_vehicles length": target_vehicles}))
if state == SIM_TAXI_FLEET.STATE.WAITING_FOR_USER_GETTING_OUT:
if user_status.state in [
SIM_TAXI_USER.STATE.GOT_OUT, USER.STATE.LOG_OUT
]:
remove_user_ids.append(user_id)
for user_id in remove_user_ids:
self.relation.remove_relations_of(
Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME))
self.state_machines.pop(user_id)
user_statuses.pop(user_id)
self.user_schedules.pop(user_id)
logger.info(
pformat({
"fleet":
dict(
map(lambda x: (x[0], x[1].state),
self.state_machines.items())),
"user":
dict(map(lambda x: (x[0], x[1].state), user_statuses.items())),
"vehicle":
dict(
map(lambda x: (x[0], x[1].state),
vehicle_statuses.items())),
}))
def __publish_user_schedules(self, user_id, payload):
self.__topicPubUserSchedules.set_targets(
self.target, Target.new_target(user_id, SIM_TAXI_USER.NODE_NAME))
self.publish(self.__topicPubUserSchedules, payload)
eventlet.monkey_patch()
app = Flask(__name__)
with app.app_context():
app.waypoint = Waypoint()
app.waypoint.load(args.path_waypoint_json)
app.arrow = Arrow()
app.arrow.load(args.path_arrow_json)
app.intersection = Intersection()
app.intersection.load(args.path_intersection_json)
app.topics = {}
topic = Topic()
topic.set_targets(Target.new_target(None, SimTaxiUser.__name__), None)
topic.set_categories(User.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["user"] = topic.get_path(use_wild_card=True)
topic = Topic()
topic.set_targets(Target.new_target(None, SimTaxi.__name__), None)
topic.set_categories(Vehicle.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["vehicle"] = topic.get_path(use_wild_card=True)
topic = Topic()
topic.set_targets(Target.new_target(None, SimTaxiFleet.__name__), None)
topic.set_categories(FleetManager.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["fleet_manager"] = topic.get_path(use_wild_card=True)
topic = Topic()
topic.set_targets(Target.new_target(None, TrafficSignal.__name__), None)
start_time = time() - 5
bus_stop_ids.remove(start_bus_stop_id)
goal_bus_stop_id = random.choice(bus_stop_ids)
goal_waypoint_id = bus_parkable_spots[goal_bus_stop_id].contact.waypoint_id
goal_arrow_code = bus_parkable_spots[goal_bus_stop_id].contact.arrow_code
bus_user = SimBusUser(_id=args.id if args.id is not None else str(uuid()),
name=args.name,
dt=3.0)
target_bus_user = Target.new_node_target(bus_user)
trip_schedule = Schedule.new_schedule(
[
target_bus_user,
Target.new_target(start_bus_stop_id,
SimBusUser.CONST.TARGET_GROUP.START_BUS_STOP),
Target.new_target(goal_bus_stop_id,
SimBusUser.CONST.TARGET_GROUP.GOAL_BUS_STOP)
], "trip_schedule", start_time, start_time + 9999,
Route.new_route(start_waypoint_id, goal_waypoint_id,
[start_arrow_code, goal_arrow_code]))
bus_user.set_trip_schedules([trip_schedule])
bus_user.set_schedules(
Schedule.new_schedules([
Schedule.new_schedule(targets=[target_bus_user],
event=User.CONST.TRIGGER.LOG_IN,
start_time=start_time,
end_time=start_time + 1),
Schedule.new_schedule(targets=[target_bus_user],
event=SimBusUser.CONST.TRIGGER.WAIT,
start_time=start_time,
if __name__ == '__main__':
mqtt_client = MQTTClient(args.host, args.port)
traffic_signal = TrafficSignal(
_id=args.id if args.id is not None else str(uuid()),
route_code=args.route_code)
process = Process(target=traffic_signal.start, args=[args.host, args.port])
process.start()
if args.cycle is not None:
sleep(5)
# print("publish cycles")
topicCycle = Topic()
topicCycle.set_targets(
Target.new_target(None, "TrafficSignalCycleSetter"),
traffic_signal.target)
topicCycle.set_categories(TrafficSignal.CONST.TOPIC.CATEGORIES.CYCLE)
mqtt_client.publish(topicCycle.get_path(),
topicCycle.serialize(json.loads(args.cycle)))
if args.schedules is not None:
sleep(5)
# print("publish schedules")
topicSchedules = Topic()
topicSchedules.set_targets(
Target.new_target(None, "TrafficSignalSchedulesSetter"),
traffic_signal.target)
topicSchedules.set_categories(
TrafficSignal.CONST.TOPIC.CATEGORIES.SCHEDULES)
mqtt_client.publish(
def get_from_target(path):
return Target.new_target(Topic.get_from_id(path),
Topic.get_from_node(path))
eventlet.monkey_patch()
app = Flask(__name__)
with app.app_context():
app.waypoint = Waypoint()
app.waypoint.load(args.path_waypoint_json)
app.arrow = Arrow()
app.arrow.load(args.path_arrow_json)
app.intersection = Intersection()
app.intersection.load(args.path_intersection_json)
app.topics = {}
topic = Topic()
topic.set_targets(Target.new_target(None, SimBusUser.__name__), None)
topic.set_categories(User.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["user"] = topic.get_path(use_wild_card=True)
topic = Topic()
topic.set_targets(Target.new_target(None, SimBus.__name__), None)
topic.set_categories(Vehicle.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["vehicle"] = topic.get_path(use_wild_card=True)
topic = Topic()
topic.set_targets(Target.new_target(None, SimBusFleet.__name__), None)
topic.set_categories(FleetManager.CONST.TOPIC.CATEGORIES.STATUS)
app.topics["fleet_manager"] = topic.get_path(use_wild_card=True)
topic = Topic()
topic.set_targets(Target.new_target(None, TrafficSignal.__name__), None)