Rover Operations Scheduler

Rover Operations Scheduler is a public-facing, cleaned-up research codebase for studying autonomous rover operations during early design phases. The work brings together MBSE, ConOps and operations analysis, AI planning, rover autonomy, and validation-oriented simulation for robotic space exploration studies.

Tags

MBSE ConOps operations robotics rover-operations autonomous-systems AI-planning mission-design early-design space-systems-engineering

Why This Repository Exists

This repository started as PhD research code and has now been reshaped into a usable software artifact.

The broader research thread behind the repository is the study of rover operations and operational concepts at early design stages, combining MBSE, robotics, mission analysis, and ConOps reasoning.

Research Lineage

All of the publications below used parts of this repository at different stages of the work.

Bibliography

• Rimani, J., Lizy-Destrez, S., and Viola, N., A Novel Approach to Planetary Rover Guidance, Navigation and Control Based on the Estimation of the Remaining Useful Life, International Astronautical Congress, 2020. ResearchGate entry: https://www.researchgate.net/publication/355873613_A_novel_approach_to_planetary_rover_guidance_navigation_and_control_based_on_the_estimation_of_the_remaining_useful_life Conference record context: https://www.proceedings.com/content/059/059806webtoc.pdf
• Rimani, J., Viola, N., and Lizy-Destrez, S., Application of a Hierarchical Task Planner to a Lunar Lava Tube Analogue Robotic Mission, International Astronautical Congress, 2021. IRIS record: https://iris.polito.it/browse?authority=rp56174&etal=-1&offset=0&order=2&rpp=20&sort_by=ASC&starts_with=&type=author
• Rimani, J., Viola, N., and Lizy-Destrez, S., Simulating Operational Concepts for Autonomous Robotic Space Exploration Systems: A Framework for Early Design Validation, Aerospace, 10(5), 408, 2023. Article: https://www.mdpi.com/2226-4310/10/5/408 DOI: 10.3390/aerospace10050408
• Rimani, J., Application of AI planning and MBSE to the Study and Optimization of ConOps for Autonomous Robotic Space Exploration Systems, PhD thesis. Entry: https://www.researchgate.net/publication/395009030_Application_of_AI_planning_and_MBSE_to_the_Study_and_Optimization_of_ConOps_for_Autonomous_Robotic_Space_Exploration_Systems

The repository also includes CITATION.cff for software-citation tooling.

What The Code Does

The maintained package focuses on the parts of the research code that are most reusable:

1. Load mission definitions from YAML, including compatibility with the original domain_requirements format.
2. Select and order science targets under a travel-distance budget.
3. Simulate a simplified rover waypoint-following response.
4. Load bundled validation telemetry and compute quick comparison metrics.
5. Generate quick-look plots for route plans, simulations, and validation data.

This is a research-oriented analysis tool, not a flight-qualified operations stack. It is meant for reproducible studies, method exploration, and early-phase mission reasoning.

Algorithms Used And Why

The repository intentionally uses a small set of understandable algorithms instead of a large opaque stack. That makes the code easier to inspect, adapt, and connect back to the research papers.

• Exact dynamic programming for route selection. Implemented in planning.py. This solver enumerates target subsets efficiently enough for small and medium problem sizes and gives an exact best route under a distance budget. It is useful when you want a trustworthy reference solution for early design trade studies.
• Greedy heuristic fallback for larger route-planning problems. Also implemented in planning.py. This keeps the tool practical when the target set grows beyond what the exact solver handles comfortably. It trades optimality for speed and simplicity.
• Euclidean-distance travel-cost model. Used throughout the route planner. This is a deliberate abstraction for early-phase analysis: it keeps the planning problem easy to interpret while still capturing first-order traversal cost between targets.
• Fourth-order Runge-Kutta integration (RK4) for rover simulation. Implemented in utilities.py and used by dynamics.py. RK4 is a standard numerical integration method that is accurate enough for this lightweight dynamics model while remaining easy to understand and reproduce.
• Proportional waypoint-following control for heading and forward speed. Implemented in dynamics.py. The controller steers the rover toward the next waypoint with simple heading and speed gains. This keeps the model readable and suitable for comparative operational studies rather than low-level flight-quality control design.
• Simplified wheel-slip and body-dynamics model. Implemented in dynamics.py. The rover response combines wheel dynamics, slip-based longitudinal forces, and a yaw moment model. It gives more physical structure than a purely kinematic path follower without turning the repository into a full multibody simulator.
• Quaternion-to-Euler conversion for telemetry interpretation. Implemented in utilities.py and used by validation.py. This makes the validation data easier to inspect because many users reason about rover attitude in yaw, pitch, and roll rather than raw quaternions.
• RMS position-gap summary metric for validation. Implemented in validation.py. The repository computes a root-mean-square positional difference between measured trajectories as a compact way to compare telemetry sources during validation-oriented analysis.

These choices are especially appropriate for the scope of this repository: they support early design, ConOps exploration, and operations studies where transparency, repeatability, and interpretability matter as much as raw realism.

Repository Structure

The repository is organized into a few clearly named areas:

• src/rover_operations_scheduler: maintained package code.
• data/validation: bundled validation telemetry in CSV form.
• examples: runnable mission definitions.
• scripts: helper scripts, including demo plot generation.
• tmp_plot: temporary generated output folder.
• legacy: reduced historical wrappers kept for context.
• tests: regression tests for the public-facing workflows.

Code Map

The main package modules are:

• config.py: YAML loading and compatibility with historical mission inputs.
• planning.py: route planning under a distance budget.
• dynamics.py: simplified rover dynamics and waypoint-following simulation.
• validation.py: validation CSV loading and summary metrics.
• plotting.py: optional plotting helpers for reports and demos.
• cli.py: the rover-ops command-line interface.
• models.py: typed data structures shared across the package.

Installation

Install the package in editable mode:

python3 -m pip install -e .

Optional extras:

python3 -m pip install -e .[dev]
python3 -m pip install -e .[plotting]

Quick Start

1. Plan a mission

python3 -m rover_operations_scheduler plan examples/mission_targets.yaml --max-distance 120

2. Simulate a short waypoint-following run

python3 -m rover_operations_scheduler simulate examples/simulation_demo.yaml

3. Summarize the bundled validation data

python3 -m rover_operations_scheduler validate data/validation

4. Generate quick-look plots in tmp_plot/

python3 scripts/generate_tmp_plots.py

That script produces:

• tmp_plot/route_plan.png
• tmp_plot/simulation_demo.png
• tmp_plot/validation_overview.png
• tmp_plot/summary.md

Python API Example

from rover_operations_scheduler import (
    RoverState,
    load_mission_definition,
    plan_route,
    simulate_waypoints,
)

mission = load_mission_definition("examples/mission_targets.yaml")
plan = plan_route(
    mission.targets,
    max_distance=mission.max_distance,
    start_position=mission.start_position,
    end_position=mission.end_position,
)

result = simulate_waypoints(
    plan.waypoint_positions,
    initial_state=RoverState(
        x=mission.start_position[0],
        y=mission.start_position[1],
    ),
    waypoint_tolerance=mission.waypoint_tolerance,
)

print(plan.total_reward, result.goal_reached)

Legacy Material

The original duplicated script trees were removed in favor of a maintainable structure. A smaller compatibility layer remains under legacy, with wrappers that point back to the maintained package instead of carrying multiple copies of the same rover model and utilities.

Current Scope And Limits

• The planner is compact and research-oriented, not a full mission-operations platform.
• The rover dynamics model is intentionally lightweight and best suited for comparative studies rather than hardware validation.
• The exact route-planning solver is best for small and medium target sets.
• The legacy material is kept for traceability, but the maintained entry point is the package under src/.

Testing

Run the test suite with:

pytest