RoboTriage: Robot Subassembly EOL Diagnostic Workbench

RoboTriage is a local end-of-line diagnostic workbench that turns simulated robot subassembly telemetry into deterministic C++ fault classifications, JSON results, technician-facing HTML reports, and a lightweight local dashboard.

Why This Project Exists

Robotics and manufacturing teams need explainable end-of-line validation tools: something that can read telemetry, reject invalid tests, classify known fault patterns, and give technicians clear evidence and next actions. RoboTriage is a portfolio-scale version of that workflow. It is intentionally scoped to local software behavior, not real robot control or hardware integration.

What It Demonstrates

• C++17 diagnostic backend for actuator and power distribution profiles
• Deterministic threshold-based classification with readable engineering logic
• CSV telemetry input and JSON threshold/action configuration
• Structured JSON diagnostic output with evidence and test validity
• Python sample generation and regression testing
• HTML reports with telemetry plots
• Streamlit technician dashboard that calls the compiled C++ CLI
• Local result history and fleet-style summary generated only from results/*.json

Architecture Overview

sample_data/*.csv
      |
      v
build/cpp/robotriage_diag --profile actuator|power
      |
      v
results/*.json
      |
      +--> tools/build_html_report.py --> reports/*.html
      |
      +--> dashboard/streamlit_app.py --> local technician workflow

The dashboard does not reimplement diagnostic logic. It blocks incomplete technician checklist runs, then calls the compiled C++ CLI.

Repository Structure

robotriage/
  CMakeLists.txt
  README.md
  VALIDATION.md
  requirements.txt
  configs/
    actuator_thresholds.json
    power_thresholds.json
    fault_actions.json
  cpp/
    CMakeLists.txt
    include/
    src/
  dashboard/
    streamlit_app.py
  docs/
    demo_script.md
    engineering_assumptions.md
    fault_library.md
    portfolio_notes.md
    project_summary.md
  expected_results/
    expected_classifications.json
  reports/
    .gitkeep
    actuator_mechanical_binding_report.html
    power_voltage_sag_report.html
  results/
    *_result.json
  sample_data/
    actuator_*.csv
    power_*.csv
  screenshots/
    .gitkeep
  tests/
    run_regression_tests.py
  tools/
    build_html_report.py
    create_demo_outputs.py
    generate_sample_data.py
    run_diagnostic_batch.py

Quick Start

Run from the repository root.

cmake -S . -B build
cmake --build build
python3 tools/generate_sample_data.py
python3 tests/run_regression_tests.py
python3 tools/create_demo_outputs.py

Expected regression proof:

Summary: 11/11 diagnostic cases passed.

Optional ROS 2 Joint Replay Harness

RoboTriage includes an optional ROS 2 Jazzy joint-replay harness that publishes simulated actuator command, state, fault-mode, and telemetry topics, then bridges ROS-derived telemetry into the existing C++ diagnostic CLI. It is verified from macOS through Docker:

scripts/run_ros_jazzy_docker_check.sh

Expected ROS extension proof lines:

Summary: 6/6 deterministic scenario exports classified correctly.
Summary: 6/6 ROS topic runtime scenarios published expected command/state/telemetry messages.
Summary: 6/6 ROS diagnostic bridge scenarios produced expected RoboTriage classifications.
Summary: 6/6 ROS joint replay scenarios passed.

The ROS extension uses simulated telemetry, not real hardware telemetry. It does not add Gazebo, MoveIt, RViz, hardware interfaces, custom ROS messages, cloud services, or AI classifiers.

Build Command

cmake -S . -B build
cmake --build build

Sample Data Generation

python3 tools/generate_sample_data.py

Regression Test Command

python3 tests/run_regression_tests.py

Example Actuator Diagnostic

build/cpp/robotriage_diag --profile actuator --input sample_data/actuator_position_lag.csv --thresholds configs/actuator_thresholds.json --actions configs/fault_actions.json --output results/actuator_position_lag_result.json

Example Power Diagnostic

build/cpp/robotriage_diag --profile power --input sample_data/power_voltage_sag.csv --thresholds configs/power_thresholds.json --actions configs/fault_actions.json --output results/power_voltage_sag_result.json

HTML Report Command

python3 tools/build_html_report.py --result results/actuator_position_lag_result.json --telemetry sample_data/actuator_position_lag.csv --output reports/actuator_position_lag_report.html

Generated demo reports included in this project:

reports/actuator_mechanical_binding_report.html
reports/power_voltage_sag_report.html

Demo Output Command

python3 tools/create_demo_outputs.py

This regenerates sample data, builds the CLI, runs all expected actuator and power diagnostics, and creates an actuator failure report plus a power failure report.

Streamlit Dashboard

Install the dashboard dependency if needed:

python3 -m pip install -r requirements.txt

Launch:

streamlit run dashboard/streamlit_app.py

If the streamlit script is not on your shell PATH, use:

python3 -m streamlit run dashboard/streamlit_app.py

Evidence And Portfolio Docs

• Validation proof
• Two-minute demo script
• Demo walkthrough
• Packaging notes
• Screenshot plan
• Portfolio notes
• ROS 2 portfolio evidence
• Docker ROS 2 Jazzy verification

Screenshot Checklist

Capture these for a portfolio page or GitHub README media section:

1. C++ CLI diagnostic command
2. Regression test passing with 11/11 diagnostic cases passed
3. JSON result output
4. HTML actuator report
5. HTML power report
6. Streamlit technician checklist
7. Streamlit diagnostic result screen
8. Streamlit local history/fleet-style summary

What This Project Is Not

• Not a robot controller
• Not a real robot or humanoid simulator
• Not an AI classifier
• Not a production ROS robot system; the optional ROS 2 extension uses simulated telemetry only
• Not a cloud service
• Not a database app
• Not a hardware integration layer
• Not a certified safety system
• Not real fleet telemetry

V2 Ideas

• Add a report index page for all local JSON results
• Add technician signoff export
• Add configurable checklist templates
• Add richer invalid-test regression fixtures
• Add combined station summary across actuator and power profiles
• Add packaging only after the local workflow is stable

Report Visualization

HTML reports include subsystem localization on a humanoid robot schematic. The affected robot region is highlighted next to evidence cards, priority metrics, telemetry plots, root-cause hints, and technician next actions. The visualization is generated from deterministic local JSON results and simulated telemetry, not live robot telemetry.