signal should implement by outside when it need.

in my case i start ScenarioExecution in thread, and i run it without ROS2.

The following code should be executed where it is needed externally, not here

class ScenarioExecution(object):
    """
    Base class for scenario execution.
    Override method run() and method setup_behaviour_tree() to adapt to other middlewares.
    This class can also be executed standalone
    """

    def __init__(self,
                 debug: bool,
                 log_model: bool,
                 live_tree: bool,
                 scenario_file: str,
                 output_dir: str,
                 dry_run=False,
                 render_dot=False,
                 setup_timeout=py_trees.common.Duration.INFINITE,
                 tick_period: float = 0.1,
                 logger=None) -> None:

        def signal_handler(sig, frame):                                     <----------here
            self.on_scenario_shutdown(False, "Aborted").       <----------here

        signal.signal(signal.SIGHUP, signal_handler)               <----------here
        signal.signal(signal.SIGTERM, signal_handler)            <----------here

        self.current_scenario_start = None

There is already the possibility to create a video of a scenario run within a github action run and publish it as an artifact.
To achieve a high level of convenience, the video would ideally also be posted as a comment to the PR, to be directly visible to the user for further analysis.

Required Skills

• CI
• github actions

If the scenario is not successful or is not executed properly, the generated test.xml file is sometimes incorrect and only contains testsuite tags.

Version information (please complete the following information):

• OS: Ubuntu 22.04
• ROS version: humble

Is your feature request related to a problem? Please describe.

Currently, we only offer how to run tutorials of scenario execution with ROS2. To support running scenario execution as standalone python library (without ROS 2), scenario_execution_base should be available as pip package in PyPi.

Describe the solution you'd like

Make scenario_execution_base available as pip package in PyPi and add corresponding section to the how to run page of the documentation.

Running colcon build --symlink-installfails.

FileNotFoundError: [Errno 2] No such file or directory: '/<path>/build/scenario_execution/README.md

Is your feature request related to a problem? Please describe.
Scripts scenario_variation and scenario_batch_execution inside scenario_coverage package needs ros2 and python prefix to run respectively.

Describe the solution you'd like
Both the scripts could be stand alone executables to run directly from command line.

Describe alternatives you've considered
A clear and concise description of any alternative solutions or features you've considered.

Additional context
Add any other context or screenshots about the feature request here.

Currently there are two modes of viewing the current state of a behavior tree.

• in terminal, using live_tree argument
• graphical visualization using ROS2 snapshot, either within RViz2 (using the scenario_execution_rviz plugin) or with the py_trees_ros_viewer.

With py_trees_js it is possible to visualize the behavior tree without the need for ROS2, using a web-socket.

Extend scenario-execution to support a py-trees-js-based visualization.

Required Skills

• Javascript
• network communication
• optional: python, C++, Qt

Challenges

While the visualization parts are already available, the main challenge is to send the required data from scenario-execution to the visualization. As an extension the visualization might also be provided by an Qt/Rviz2 plugin.

Describe the bug
When controlling AMR navigation scenarios with scenario_execution_control via rviz and the user stops the scenario during execution of a navigation action, it is not properly stopped, but the robot continues to navigate to its goal although the scenario was already stopped. Hence, the cleanup function of the nav_to_pose action is not properly called in this case. The problem seems to be related to Threading in the scenario_runner.

To Reproduce
Run the scenario control example according to the corresponding tutorial and stop the scenario while the robot is navigating towards a goal.

Expected behavior
The robot should stop its current navigation mission immediately after the scenario is stopped from rviz.

Screenshots

Version information:

• OS: Ubuntu 22.04
• Version 1.0.0
• ROS version: humble

To show the versatility of scenario_execution we want to create an example that shows how scenarios can be used in AI training tasks.

Some ideas:

• make use of ros2_openvino_toolkit
• make use of a basic example, e.g. from gymnasium to showcase a reinforcement learning.
• use scenario variation to create large datasets.
• see this student project implementing Q-Learning with the Turtlebot3 in ROS1 and Gazebo Classic for inspiration

Required Skills

• Python
• basics of reinforcement learning (e.g. using gymnasium or other AI approaches

Challenges

Use scenario-execution to create many scenarios and show that robustness increases.

• enable iron tests in CI

We want to have a reasonable pedestrian simulation, either with Gazebo or another simulator.

Gazebo Approach

Gazebo supports walking pedestrians (tutorial). scenario_execution should be able to control the movement.

Possible actions

• move_along_path
• move_to_pose

Required Skills

• C++

Challenges

The task might require to at least partially understand the architecture of Gazebo in order to modify/create C++ plugins

At the moment only Gazebo and PyBullet are supported (through the library scenario_execution_gazebo and scenario_execution_pybullet).

We would like to support further simulations.

Potential simulators to support (list might get extended):

• MuJoCo
• carla
• webots

Required Skills

• Python
• (optional) simulator-specific knowledge
• (optional) ROS2 basics

Challenges

Interfacing a new simulator through scenario-execution might be challenging because of the different design decisions. While e.g. Gazebo is "ticking" (i.e. moving forward in simulation time) stand-alone and publishing data to ROS2 directly (through network interfaces) others might need scenario-execution to tick (e.g. scenario_execution_pybullet).

Describe the bug
Trying to use run_external_process() from a osc file fails
as it is said to be used in the helpers.osc as a string

To Reproduce
in a osc file use:
serial:
run_external_process() with:
keep(it.command == "ros2 run x y")

Expected behavior
an external command should be started successfully

Screenshots
If applicable, add screenshots to help explain your problem.

Version information (please complete the following information):

• OS: [e.g. Ubuntu 22.04]
• Version [e.g. 1.0.0]
• ROS version: [e.g. humble]

Additional context
Add any other context about the problem here.

• add scripts/dockerfile
• Document:
  • how to build dev container
  • how to use dev container

Make simulation features accessible through scenario-execution (e.g. apply impulse, move)

Currently only basic features are available, like spawning or deleting actors.

Identify potential use-cases/functionality, implement simulator-specific actions.

Examples

• Add impulse to actor
• Move actor
• check for collisions

Use cases

• robot moving within a factory
• humans within an office environment
• last-mile delivery robots
• ....

Required Skills

• Python
• understanding of potential challenges for robots

Currently, the only supported method for capturing data with scenario execution is using ROS2 (using the action record_bag).

We want to support at least one other simulation, e.g. pybullet and provide a (generic) approach to capture data.

Example:

import osc.helpers
import osc.pybullet
import osc.data_writer # <-- new library

scenario example_pybullet:
    timeout(60s)
    sim: simulation_pybullet
    actor1: actor_pybullet
    writer: kitti_writer("./my_dataset", "odometry1") # <-- new actor
    do serial:
        sim.initialize("plane.urdf")
        actor1.spawn("husky/husky.urdf", pose_3d(position: position_3d(z: 0.5)))
        parallel:
            sim.run()
            writer.capture() # <-- new action
            actor1.set_joint_motor_control(5mps, 1)
            serial:
                actor1.distance_traveled(2m)
                emit end

In this example only the odometry might be captured (as no image provider is instantiated).

Different data annotation formats might be supported, e.g.:

• kitti
• csv/jpg
• ...

Stretch Goal

Create example on how to use captured dataset to train an AI.

Describe the bug
when using log_check to find a message in rosout, scenario_execution will print out
an instantiate action message containing the message that needs to be found in rosout

To Reproduce
use log_check in osc file and echo the rosout topic

Expected behavior
i think that the log_check should also look at the name field from rosout instead of just msg.msg

Screenshots
If applicable, add screenshots to help explain your problem.

Version information (please complete the following information):

• OS: [e.g. Ubuntu 22.04]
• Version [e.g. 1.0.0]
• ROS version: [e.g. humble]

Additional context
Add any other context about the problem here.

pixi tool can help developers quickly build ROS2 development environments

this tool package can find in conda-forge

With #124 the package nav2_minimal_turtlebot_simulation got included as submodule. This was required to include the latest changes not yet released as debian package.

Once a new debian release gets available, remove the submodule.

Make scenario_execution available in ros debian repositories.

Starting point: https://github.com/IntelLabs/scenario_execution/tree/update_py_trees_dependency

TODOs

• py_trees_ros release available with splintered-reality/py_trees_ros#220
• get rid of git submodules

Describe the bug
When using library imports, parsing get significantly slower.

To Reproduce
Use scenario with many large scenario library imports.

Expected behavior
Parsing finished within 2-3s.

Describe the bug
If scenario_batch_execution gets canceled (e.g. in CI) no test.xml gets created.

Expected behavior
test.xml should be created and contain test aborted info.