Migrate from LabVIEW to Python

python -m venv venv
source venv/bin/activate    # Linux/macOS
# venv\Scripts\activate     # Windows

pip install openhtf tofupilot pyvisa pyvisa-py

def measure_voltage(channel: int) -> float:
    """Equivalent of a LabVIEW SubVI that reads voltage from a DMM.

    In LabVIEW: SubVI with channel input (I32) and voltage output (DBL).
    In Python: function with type hints.
    """
    readings = {1: 3.31, 2: 5.02, 3: 1.81}  # Replace with real reads
    return readings.get(channel, 0.0)


# Call it like you'd wire a SubVI
rail_3v3 = measure_voltage(1)
rail_5v0 = measure_voltage(2)

class InstrumentError(Exception):
    """Replaces LabVIEW error cluster for instrument errors."""

    def __init__(self, code: int, source: str, message: str):
        self.code = code
        self.source = source
        super().__init__(f"[{code}] {source}: {message}")


# LabVIEW: check error cluster at every node
# Python: try/except catches errors from anywhere in the block
try:
    voltage = measure_voltage(1)
    if voltage < 0:
        raise InstrumentError(1001, "DMM", "Negative voltage reading")
except InstrumentError as e:
    print(f"Instrument error: {e}")
    # Handle or re-raise

class TestSequencer:
    """Replaces a LabVIEW state machine for test sequencing."""

    def __init__(self):
        self.results = {}
        self.state = "init"

    def run_step(self, name: str, func, limits: tuple) -> bool:
        """Run a test step and record the result."""
        value = func()
        passed = limits[0] <= value <= limits[1]
        self.results[name] = {
            "value": value,
            "limits": limits,
            "passed": passed,
        }
        return passed

    def run(self):
        """Execute the full test sequence."""
        self.run_step("rail_3v3", lambda: 3.31, (3.2, 3.4))
        self.run_step("rail_5v0", lambda: 5.02, (4.8, 5.2))

        all_passed = all(r["passed"] for r in self.results.values())
        return all_passed


seq = TestSequencer()
passed = seq.run()
print(f"Test {'PASSED' if passed else 'FAILED'}")

import openhtf as htf
from openhtf.plugs import BasePlug
from openhtf.util import units
from tofupilot.openhtf import TofuPilot


class InstrumentPlug(BasePlug):
    """Replaces LabVIEW instrument driver VIs.

    setUp = equivalent of opening a VISA session in LabVIEW
    methods = equivalent of SubVIs for each measurement
    tearDown = equivalent of closing the session
    """

    def setUp(self):
        self._voltages = iter([3.31, 5.02])
        # Replace with: rm = pyvisa.ResourceManager("@py")
        # self.instr = rm.open_resource("TCPIP::192.168.1.100::INSTR")

    def read_voltage(self) -> float:
        return next(self._voltages)
        # Replace with: return float(self.instr.query(":MEAS:VOLT:DC?"))

    def tearDown(self):
        pass
        # Replace with: self.instr.close()


@htf.measures(
    htf.Measurement("rail_3v3")
    .in_range(3.2, 3.4)
    .with_units(units.VOLT)
    .doc("3.3V rail"),
    htf.Measurement("rail_5v0")
    .in_range(4.8, 5.2)
    .with_units(units.VOLT)
    .doc("5.0V rail"),
)
@htf.plug(instr=InstrumentPlug)
def test_power_rails(test, instr):
    """Replaces a LabVIEW test sequence with Numeric Limit Tests."""
    test.measurements.rail_3v3 = instr.read_voltage()
    test.measurements.rail_5v0 = instr.read_voltage()


def main():
    test = htf.Test(
        test_power_rails,
        procedure_id="FCT-001",
        part_number="PCBA-100",
    )
    with TofuPilot(test):
        test.execute(test_start=lambda: input("Scan serial number: "))


if __name__ == "__main__":
    main()