Flex stacker pvt qc - Stallguard Test + current speed updates (#18511)

# Overview

- Created a new folder to hold the final PVT/MP versions of the scripts
- Created a new Stallguard test 
- Updated values of the current speed test to reflect DVT testing
learnings
- This is now a working base for further PVT diagnostic script updates
and testing

## Test Plan and Hands on Testing

- Tested function of all tests with Flex and DVT stacker running:
- Robot server: 8.5.0-alpha.1
- Stacker FW: v0.0.7


## Changelog

- Created a new Stallguard test 
- Updated values of the current speed test to reflect DVT testing
learnings

## Review requests



## Risk assessment

Author: djgomez-opentrons

hardware-testing/hardware_testing/modules/flex_stacker_qc/__init__.py

@@ -0,0 +1 @@
+"""FLEX Stacker QC scripts."""

hardware-testing/hardware_testing/modules/flex_stacker_qc/__main__.py

@@ -0,0 +1,107 @@
+"""FLEX Stacker QC."""
+from os import environ
+
+# NOTE: this is required to get WIFI test to work
+if "OT_SYSTEM_VERSION" not in environ:
+    environ["OT_SYSTEM_VERSION"] = "0.0.0"
+
+import argparse
+import asyncio
+import subprocess
+from pathlib import Path
+from typing import Tuple
+
+from hardware_testing.data import ui
+from hardware_testing.data.csv_report import CSVReport
+
+from .config import TestSection, TestConfig, build_report, TESTS
+from .driver import FlexStackerInterface, PlatformState
+
+
+async def build_stacker_report(
+    is_simulating: bool,
+) -> Tuple[CSVReport, FlexStackerInterface]:
+    """Report setup for FLEX Stacker qc script."""
+    test_name = Path(__file__).parent.name.replace("_", "-")
+    ui.print_title(test_name.upper())
+
+    stacker = (
+        await FlexStackerInterface.build_simulator()
+        if is_simulating
+        else await FlexStackerInterface.build()
+    )
+
+    report = build_report(test_name)
+    report.set_operator(
+        "simulating" if is_simulating else input("enter OPERATOR name: ")
+    )
+    return report, stacker
+
+
+async def _main(cfg: TestConfig) -> None:
+    # BUILD REPORT
+    report, stacker = await build_stacker_report(cfg.simulate)
+
+    if not cfg.simulate:
+        print("Stopping the robot server")
+        subprocess.run(["systemctl stop opentrons-robot-server"], shell=True)
+        # Perform initial checks before starting tests
+        # 1. estop should not be pressed
+        # 2. platform should be removed
+        if await stacker.get_estop():
+            ui.print_error("ESTOP is pressed, please release it before starting")
+            ui.get_user_ready("Release ESTOP")
+            if stacker.get_estop():
+                ui.print_error("ESTOP is still pressed, cannot start tests")
+                return
+
+        # TODO: This check should be in the basic axes tests
+        platform_state = await stacker.get_platform_state()
+        if platform_state is not PlatformState.UNKNOWN:
+            ui.print_error("Platform must be removed from the carrier before starting")
+            ui.get_user_ready("Remove platform from {platform_state.value}")
+            if await stacker.get_platform_state() is not PlatformState.UNKNOWN:
+                ui.print_error("Platform is still detected, cannot start tests")
+                return
+
+    device_info = await stacker._driver.get_device_info()
+    report.set_tag(device_info.sn if device_info.sn else "UNKNOWN")
+
+    # RUN TESTS
+    try:
+        for section, test_run in cfg.tests.items():
+            ui.print_title(section.value)
+            await test_run(stacker, report, section.value)
+    except Exception as e:
+        ui.print_error(f"An error occurred: {e}")
+
+    # SAVE REPORT
+    ui.print_title("DONE")
+    report.save_to_disk()
+    report.print_results()
+
+    # Restart the robot server
+    if not cfg.simulate:
+        print("Starting the robot server")
+        subprocess.run(["systemctl restart opentrons-robot-server &"], shell=True)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--simulate", action="store_true")
+    # add each test-section as a skippable argument (eg: --skip-connectivity)
+    for s in TestSection:
+        parser.add_argument(f"--skip-{s.value.lower()}", action="store_true")
+        parser.add_argument(f"--only-{s.value.lower()}", action="store_true")
+    args = parser.parse_args()
+    _t_sections = {s: f for s, f in TESTS if getattr(args, f"only_{s.value.lower()}")}
+    if _t_sections:
+        assert (
+            len(list(_t_sections.keys())) < 2
+        ), 'use "--only" for just one test, not multiple tests'
+    else:
+        _t_sections = {
+            s: f for s, f in TESTS if not getattr(args, f"skip_{s.value.lower()}")
+        }
+    _config = TestConfig(simulate=args.simulate, tests=_t_sections)
+    asyncio.run(_main(_config))

hardware-testing/hardware_testing/modules/flex_stacker_qc/config.py

@@ -0,0 +1,175 @@
+"""Config."""
+from dataclasses import dataclass
+import enum
+from typing import Dict, Callable
+
+from hardware_testing.data.csv_report import CSVReport, CSVSection
+
+from . import (
+    test_connectivity,
+    test_z_axis_basic,
+    test_x_axis_basic,
+    test_l_axis_basic,
+    test_z_axis_current_speed,
+    test_x_axis_current_speed,
+    test_stallguard,
+    test_door_switch,
+    test_estop,
+    test_ui_leds,
+    test_uv_lockout_switch,
+    test_install_detection,
+    test_tof_basic,
+    test_tof_functional,
+)
+
+
+class TestSection(enum.Enum):
+    """Test Section."""
+
+    CONNECTIVITY = "CONNECTIVITY"
+    DOOR_SWITCH = "DOOR_SWITCH"
+    ESTOP = "ESTOP"
+    Z_AXIS_BASIC = "Z_AXIS_BASIC"
+    L_AXIS_BASIC = "L_AXIS_BASIC"
+    X_AXIS_BASIC = "X_AXIS_BASIC"
+    STALLGUARD = "STALLGUARD"
+    UI_LEDS = "UI_LEDS"
+    UV_LOCKOUT_SWITCH = "UV_LOCKOUT_SWITCH"
+    INSTALL_DETECTION = "INSTALL_DETECTION"
+    TOF_BASIC = "TOF_BASIC"
+    TOF_FUNCTIONAL = "TOF_FUNCTIONAL"
+    Z_AXIS_CURRENT_SPEED = "Z_AXIS_CURRENT_SPEED"
+    X_AXIS_CURRENT_SPEED = "X_AXIS_CURRENT_SPEED"
+
+
+@dataclass
+class TestConfig:
+    """Test Config."""
+
+    simulate: bool
+    tests: Dict[TestSection, Callable]
+
+
+TESTS = [
+    (
+        TestSection.CONNECTIVITY,
+        test_connectivity.run,
+    ),
+    (
+        TestSection.Z_AXIS_BASIC,
+        test_z_axis_basic.run,
+    ),
+    (
+        TestSection.X_AXIS_BASIC,
+        test_x_axis_basic.run,
+    ),
+    (
+        TestSection.L_AXIS_BASIC,
+        test_l_axis_basic.run,
+    ),
+    (
+        TestSection.STALLGUARD,
+        test_stallguard.run,
+    ),
+    (
+        TestSection.ESTOP,
+        test_estop.run,
+    ),
+    (
+        TestSection.DOOR_SWITCH,
+        test_door_switch.run,
+    ),
+    (
+        TestSection.UI_LEDS,
+        test_ui_leds.run,
+    ),
+    (
+        TestSection.UV_LOCKOUT_SWITCH,
+        test_uv_lockout_switch.run,
+    ),
+    (
+        TestSection.INSTALL_DETECTION,
+        test_install_detection.run,
+    ),
+    (
+        TestSection.TOF_BASIC,
+        test_tof_basic.run,
+    ),
+    (
+        TestSection.TOF_FUNCTIONAL,
+        test_tof_functional.run,
+    ),
+    (
+        TestSection.Z_AXIS_CURRENT_SPEED,
+        test_z_axis_current_speed.run,
+    ),
+    (
+        TestSection.X_AXIS_CURRENT_SPEED,
+        test_x_axis_current_speed.run,
+    ),
+]
+
+
+def build_report(test_name: str) -> CSVReport:
+    """Build report."""
+    return CSVReport(
+        test_name=test_name,
+        sections=[
+            CSVSection(
+                title=TestSection.CONNECTIVITY.value,
+                lines=test_connectivity.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.ESTOP.value,
+                lines=test_estop.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.DOOR_SWITCH.value,
+                lines=test_door_switch.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.Z_AXIS_BASIC.value,
+                lines=test_z_axis_basic.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.X_AXIS_BASIC.value,
+                lines=test_x_axis_basic.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.L_AXIS_BASIC.value,
+                lines=test_l_axis_basic.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.STALLGUARD.value,
+                lines=test_stallguard.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.UI_LEDS.value,
+                lines=test_ui_leds.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.UV_LOCKOUT_SWITCH.value,
+                lines=test_uv_lockout_switch.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.INSTALL_DETECTION.value,
+                lines=test_install_detection.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.TOF_BASIC.value,
+                lines=test_tof_basic.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.TOF_FUNCTIONAL.value,
+                lines=test_tof_functional.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.Z_AXIS_CURRENT_SPEED.value,
+                lines=test_z_axis_current_speed.build_csv_lines(),
+            ),
+            CSVSection(
+                title=TestSection.X_AXIS_CURRENT_SPEED.value,
+                lines=test_x_axis_current_speed.build_csv_lines(),
+            ),
+        ],
+    )