Set SimBasicDrone as default ID so then it can be loaded by other instance of world client

Author: aurebidart

client/python/example_user_scripts/hello_drone_secondary.py

@@ -1,102 +1,117 @@
 """
-Copyright (C) Microsoft Corporation.  
+Copyright (C) Microsoft Corporation.
 Copyright (C) 2025 IAMAI Consulting Corp.
 MIT License. All rights reserved.
 
-Demonstrates flying a quadrotor drone with camera sensors.
+Secondary controller+viewer: flies the drone AND subscribes to camera topics to show images.
 """
 
 import asyncio
+import signal
 
 from projectairsim import ProjectAirSimClient, Drone, World
 from projectairsim.utils import projectairsim_log
 from projectairsim.image_utils import ImageDisplay
 
-# Async main function to wrap async drone commands
+
 async def main():
-    # Create a Project AirSim client
     client = ProjectAirSimClient()
-
-    # Initialize an ImageDisplay object to display camera sub-windows
     image_display = ImageDisplay()
 
+    # Graceful shutdown with Ctrl+C
+    stop_event = asyncio.Event()
     try:
-        # Connect to simulation environment
-        client.connect()
-
-        # Create a World object to interact with the sim world and load a scene
-        world = World(client, "scene_two_drones.jsonc", delay_after_load_sec=2, actual_load=False)
-
-        # Create a Drone object to interact with a drone in the loaded sim world
-        drone = Drone(client, world, "Drone2")
-
-        # ------------------------------------------------------------------------------
+        signal.signal(signal.SIGINT, lambda *_: stop_event.set())
+    except Exception:
+        pass
 
+    try:
+        # 1) Connect to the running simulation (primary already loaded the scene)
+        client.connect()
 
-        # Set the drone to be ready to fly
+        # 2) Attach to current world without loading a new scene
+        world = World(client)
+
+        # 3) Attach to the existing drone
+        drone = Drone(client, world, "Drone1")
+
+        # ----------------- SUBSCRIPTIONS (viewer) -----------------
+        # Downward RGB
+        rgb_win = "RGB-Image (Secondary)"
+        image_display.add_image(rgb_win, subwin_idx=0)
+        try:
+            down_rgb_topic = drone.sensors["DownCamera"]["scene_camera"]
+        except Exception:
+            down_rgb_topic = "/Sim/SceneBasicDrone/robots/Drone1/sensors/DownCamera/scene_camera"
+        client.subscribe(down_rgb_topic, lambda _, msg: image_display.receive(msg, rgb_win))
+
+        # Depth
+        depth_win = "Depth-Image (Secondary)"
+        image_display.add_image(depth_win, subwin_idx=2)
+        try:
+            down_depth_topic = drone.sensors["DownCamera"]["depth_camera"]
+        except Exception:
+            down_depth_topic = "/Sim/SceneBasicDrone/robots/Drone1/sensors/DownCamera/depth_camera"
+        client.subscribe(down_depth_topic, lambda _, msg: image_display.receive(msg, depth_win))
+
+        # Chase cam
+        chase_win = "ChaseCam (Secondary)"
+        image_display.add_chase_cam(chase_win)
+        try:
+            chase_topic = drone.sensors["Chase"]["scene_camera"]
+        except Exception:
+            chase_topic = "/Sim/SceneBasicDrone/robots/Drone1/sensors/Chase/scene_camera"
+        client.subscribe(chase_topic, lambda _, msg: image_display.receive(msg, chase_win))
+
+        # Start viewer windows
+        image_display.start()
+
+        # ----------------- FLIGHT SEQUENCE (control) -----------------
+        # Keep the same behavior you had: enable, arm, takeoff, move up/down, land
         drone.enable_api_control()
         drone.arm()
 
-        # ------------------------------------------------------------------------------
-
         projectairsim_log().info("takeoff_async: starting")
-        takeoff_task = (
-            await drone.takeoff_async()
-        )  # schedule an async task to start the command
-
-        # Example 1: Wait on the result of async operation using 'await' keyword
+        takeoff_task = await drone.takeoff_async()
         await takeoff_task
         projectairsim_log().info("takeoff_async: completed")
 
-        # ------------------------------------------------------------------------------
-
-        # Command the drone to move up in NED coordinate system at 1 m/s for 4 seconds
+        # Move up 1 m/s for 4 s
         move_up_task = await drone.move_by_velocity_async(
             v_north=0.0, v_east=0.0, v_down=-1.0, duration=4.0
         )
         projectairsim_log().info("Move-Up invoked")
-
         await move_up_task
         projectairsim_log().info("Move-Up completed")
 
-        # ------------------------------------------------------------------------------
-
-        # Command the Drone to move down in NED coordinate system at 1 m/s for 4 seconds
+        # Move down 1 m/s for 4 s
         move_down_task = await drone.move_by_velocity_async(
             v_north=0.0, v_east=0.0, v_down=1.0, duration=4.0
-        )  # schedule an async task to start the command
+        )
         projectairsim_log().info("Move-Down invoked")
-
-        # Example 2: Wait for move_down_task to complete before continuing
         while not move_down_task.done():
             await asyncio.sleep(0.005)
         projectairsim_log().info("Move-Down completed")
 
-        # ------------------------------------------------------------------------------
-
         projectairsim_log().info("land_async: starting")
         land_task = await drone.land_async()
         await land_task
         projectairsim_log().info("land_async: completed")
 
-        # ------------------------------------------------------------------------------
+        # Keep windows open until Ctrl+C (optional)
+        projectairsim_log().info("Viewer running. Press Ctrl+C to quit.")
+        await stop_event.wait()
 
-        # Shut down the drone
+        # Disarm/disable after viewing (optional)
         drone.disarm()
         drone.disable_api_control()
 
-        # ------------------------------------------------------------------------------
-
-    # logs exception on the console
     except Exception as err:
         projectairsim_log().error(f"Exception occurred: {err}", exc_info=True)
-
     finally:
-        # Always disconnect from the simulation environment to allow next connection
         client.disconnect()
-
         image_display.stop()
 
 
 if __name__ == "__main__":
-    asyncio.run(main())  # Runner for async main function
+    asyncio.run(main())

client/python/projectairsim/src/projectairsim/drone.py

@@ -74,6 +74,9 @@ def set_sensor_topics(self, world: World):
         scene_config_data = world.get_configuration()
         data = None
 
+        if scene_config_data is None:
+            return
+
         for actor in scene_config_data["actors"]:
             if actor["name"] == self.name:
                 data = actor["robot-config"]

client/python/projectairsim/src/projectairsim/world.py

@@ -42,7 +42,6 @@ def __init__(
         delay_after_load_sec: int = 0,
         sim_config_path: str = "sim_config/",
         sim_instance_idx: int = -1,
-        actual_load: bool = True,
     ):
         """ProjectAirSim World Interface.
 
@@ -71,7 +70,7 @@ def __init__(
             self.robot_config_paths = config_paths[1]
             self.envactor_config_paths = config_paths[2]
             self.envobject_config_paths = config_paths[3]
-            self.load_scene(config_dict, delay_after_load_sec=delay_after_load_sec, actual_load = actual_load)
+            self.load_scene(config_dict, delay_after_load_sec=delay_after_load_sec)
         random.seed()
         self.import_ned_trajectory(
             "null_trajectory", [0, 1], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0], [0, 0]
@@ -83,6 +82,12 @@ def get_configuration(self) -> Dict:
         Returns:
             Dict: the configuration
         """
+        # self.sim_config is not setted when World is created without parameters
+        if self.sim_config is None:
+            projectairsim_log().info(
+                f"World '{self.parent_topic}' was created without parameters"
+            )
+            return None
         return self.sim_config
 
     def get_sim_clock_type(self) -> str:
@@ -1007,7 +1012,7 @@ def set_sun_position_from_date_time(
         return status
 
     def load_scene(
-        self, scene_config_dict: Dict, delay_after_load_sec: float = 0, actual_load: bool = True
+        self, scene_config_dict: Dict, delay_after_load_sec: float = 0
     ) -> str:
         """(Re)loads the sim scene config to the sim server
 
@@ -1021,9 +1026,7 @@ def load_scene(
 
         # Force sim to pause on start if there are objects to spawn
         clock_is_steppable = scene_config_dict["clock"]["type"] == "steppable"
-        pause_on_start_by_user = False
-        if scene_config_dict["clock"].get("pause-on-start") is not None:
-            pause_on_start_by_user = scene_config_dict["clock"]["pause-on-start"]
+        pause_on_start_by_user = scene_config_dict["clock"].get("pause-on-start", False)
 
         if scene_config_dict.get("spawn-objects") is not None:
             if clock_is_steppable:
@@ -1044,12 +1047,9 @@ def load_scene(
         }
         self.sim_config = scene_config_dict
 
-        if(actual_load):
-            self.client.unsubscribe_all()
-            scene_id = self.client.request(load_scene_req)
-            self.client.get_topic_info()  # get new scene's list of registered topic info
-        else:
-            scene_id = scene_config_dict["id"]
+        self.client.unsubscribe_all()
+        scene_id = self.client.request(load_scene_req)
+        self.client.get_topic_info()  # get new scene's list of registered topic info
 
         time.sleep(delay_after_load_sec)
         self.parent_topic = f"/Sim/{scene_id}"