def run_setup(self):
from monodrive import SimulatorConfiguration, VehicleConfiguration, Simulator
from monodrive.ui import GUI
from monodrive.networking.client import Client
# Simulator configuration defines network addresses for connecting to the simulator and material properties
simulator_config = SimulatorConfiguration('simulator.json')
self.client = Client((simulator_config.configuration["server_ip"],
simulator_config.configuration["server_port"]))
if not self.client.isconnected():
self.client.connect()
# Vehicle configuration defines ego vehicle configuration and the individual sensors configurations
vehicle_config = VehicleConfiguration('demo.json')
self.simulator = Simulator(self.client, simulator_config)
self.simulator.send_configuration()
self.map_data = self.simulator.request_map()
from monodrive import VehicleConfiguration
from monodrive.vehicles import LV_Vehicle
# Setup Ego Vehicle
vehicle_config = VehicleConfiguration('demo.json')
self.ego_vehicle = LV_Vehicle(simulator_config, vehicle_config,
self.restart_event, self.map_data)
# Send Radar Waveform
self.ego_vehicle.update_fmcw_in_config()
#helper = InterruptHelper()
self.simulator.restart_event.clear()
self.simulator.send_vehicle_configuration(vehicle_config)
time.sleep(1)
return True
def main():
# Simulator configuration defines network addresses for connecting to the simulator and material properties
simulator_config = SimulatorConfiguration('simulator.json')
sim_config_yaml = yaml.load(json.dumps(simulator_config.configuration))
if rospy.has_param('monodrive/sensors'):
rospy.delete_param('monodrive/sensors')
for param in sim_config_yaml:
#print param, ":", sim_config_yaml[param]
rospy.set_param('/monodrive/' + param, sim_config_yaml[param])
# Vehicle configuration defines ego vehicle configuration and the individual sensors configurations
vehicle_config = VehicleConfiguration('demo.json')
vehicle_config_yaml = yaml.load(json.dumps(vehicle_config.configuration))
for param in vehicle_config_yaml:
if param == 'sensors':
for sensors in vehicle_config_yaml['sensors']:
for p in sensors:
rospy.set_param(
'/monodrive/sensors/' + sensors['type'] + '/' +
sensors['id'] + '/' + p, sensors[p])
else:
print "not included in params " + param
import roslib
roslib.load_manifest("rosparam")
params = rospy.get_param('monodrive')
host = params['host']
port = params['port']
num_episodes = params['Episodes']
rospy.init_node("monodrive_client", anonymous=True)
rospy.loginfo("Trying to connect to {host}:{port}".format(host=host,
port=port))
for episode in range(0, num_episodes):
if rospy.is_shutdown():
break
rospy.loginfo("Starting Episode --> {}".format(episode))
current_eps = '_episode' + '_' + str(episode)
rospy.set_param(param_name='curr_episode', param_value=current_eps)
rospy.set_param(param_name='SimulatorConfig',
param_value='simulator.json')
rospy.set_param(param_name='VehicleConfig', param_value='demo.json')
bridge_cls = MonoRosBridgeWithBag if rospy.get_param(
'rosbag_fname', '') else MonoRosBridge
with bridge_cls(params=params) as mono_ros_bridge:
rospy.on_shutdown(mono_ros_bridge.on_shutdown)
mono_ros_bridge.run()
def start_ego(self):
from monodrive import VehicleConfiguration
from monodrive.vehicles import TeleportVehicle
# Setup Ego Vehicle
vehicle_config = VehicleConfiguration('demo.json')
self.ego_vehicle = TeleportVehicle(self.simulator, vehicle_config,
self.restart_event, self.map_data)
# Send Radar Waveform
self.ego_vehicle.update_fmcw_in_config()
self.ego_vehicle.start()
def start_scenario(self, scenario, vehicle_class):
self.scenario = scenario
# Send both simulator configuration and scenario
# self.send_configuration(self.configuration)
self.send_scenario(scenario)
# Get Ego vehicle configuration from scenario, use that to create vehicle process
vehicle_configuration = scenario.ego_vehicle_config
vehicle_configuration = VehicleConfiguration.init_from_json(
vehicle_configuration.to_json)
self.ego_vehicle = vehicle_class(self, vehicle_configuration,
self.restart_event)
# Start the Vehicle process
self.ego_vehicle.start_scenario(scenario)
def __init__(self, params):
"""
:param params: dict of parameters, see settings.yaml
:param rate: rate to query data from mono in Hz
"""
self.frames_per_episode = params['Framesperepisode']
# Simulator configuration defines network addresses for connecting to the simulator and material properties
simulator_config = SimulatorConfiguration(params['SimulatorConfig'])
# Vehicle configuration defines ego vehicle configuration and the individual sensors configurations
self.vehicle_config = VehicleConfiguration(params['VehicleConfig'])
self.simulator = Simulator(simulator_config)
self.vehicle = self.simulator.get_ego_vehicle(self.vehicle_config,
RosVehicle)
self.param_sensors = params.get('sensors', {})
self.tf_to_publish = []
self.msgs_to_publish = []
self.publishers = {}
# definitions useful for time
self.cur_time = rospy.Time.from_sec(
0) # at the beginning of simulation
self.mono_game_stamp = 0
self.mono_platform_stamp = 0
# creating handler to handle vehicles messages
self.player_handler = PlayerAgentHandler(
"player_vehicle", process_msg_fun=self.process_msg)
self.non_players_handler = NonPlayerAgentsHandler(
"vehicles", process_msg_fun=self.process_msg)
# creating handler for sensors
self.sensors = {}
print(self.param_sensors)
for t, sensors in self.param_sensors.items():
for id in sensors:
self.add_sensor(sensors[id])
from monodrive.ui import GUI
from monodrive.util import InterruptHelper
from monodrive.vehicles import SimpleVehicle
from monodrive.vehicles import TeleportVehicle
from monodrive.networking.client import Client
ManualDriveMode = True
if __name__ == "__main__":
# Simulator configuration defines network addresses for connecting to the simulator and material properties
simulator_config = SimulatorConfiguration('simulator.json')
# Vehicle configuration defines ego vehicle configuration and the individual sensors configurations
vehicle_config = VehicleConfiguration('demo.json')
client = Client((simulator_config.configuration["server_ip"],
simulator_config.configuration["server_port"]))
if not client.isconnected():
client.connect()
simulator = Simulator(client, simulator_config)
simulator.setup_logger()
simulator.send_configuration()
time.sleep(2)
episodes = 1 # TODO... this should come from the scenario config
# Setup Ego Vehicle
def score(self, control_data):
print('offset: ', control_data['offset'])
reward = -math.fabs(control_data['offset']) - math.fabs(
control_data['speed_limit'] - control_data['speed'])
done = control_data[
'restart'] or self.should_restart_vehicle or self.brain.reward_sum < -1000
print(reward, done)
return reward, done
if __name__ == "__main__":
simulator_config = SimulatorConfiguration('simulator.json')
vehicle_config = VehicleConfiguration('training.json')
agent_config = Configuration('../examples/agent_trainer_config.json')
dim = int(agent_config.configuration["image_width"] / agent_config.configuration["down_sample"] * \
agent_config.configuration["image_height"] / agent_config.configuration["down_sample"])
brain = SimpleNeuralNetwork(
hidden_layers=agent_config.configuration['hidden_layers'],
outputs=agent_config.configuration['outputs'],
dimensionality=dim,
gamma=agent_config.configuration['gamma'],
down_sample=agent_config.configuration['down_sample'],
batch_size=agent_config.configuration['batch_size'],
decay_rate=agent_config.configuration['decay_rate'],
learning_rate=agent_config.configuration['learning_rate'],
resume=agent_config.configuration['resume'])