Migrer de LabVIEW vers 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:
    """Équivalent d'un SubVI LabVIEW qui lit la tension d'un DMM.

    En LabVIEW : SubVI avec entrée canal (I32) et sortie tension (DBL).
    En Python : fonction avec annotations de type.
    """
    readings = {1: 3.31, 2: 5.02, 3: 1.81}  # Remplacer par de vraies lectures
    return readings.get(channel, 0.0)


# L'appeler comme on câblerait un SubVI
rail_3v3 = measure_voltage(1)
rail_5v0 = measure_voltage(2)

class InstrumentError(Exception):
    """Remplace le cluster d'erreur LabVIEW pour les erreurs d'instrument."""

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


# LabVIEW : vérifier le cluster d'erreur à chaque nœud
# Python : try/except attrape les erreurs de n'importe où dans le bloc
try:
    voltage = measure_voltage(1)
    if voltage < 0:
        raise InstrumentError(1001, "DMM", "Lecture de tension négative")
except InstrumentError as e:
    print(f"Erreur d'instrument : {e}")
    # Gérer ou relancer

class TestSequencer:
    """Remplace une machine d'états LabVIEW pour le séquencement de tests."""

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

    def run_step(self, name: str, func, limits: tuple) -> bool:
        """Exécuter une étape de test et enregistrer le résultat."""
        value = func()
        passed = limits[0] <= value <= limits[1]
        self.results[name] = {
            "value": value,
            "limits": limits,
            "passed": passed,
        }
        return passed

    def run(self):
        """Exécuter la séquence de test complète."""
        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 {'RÉUSSI' if passed else 'ÉCHOUÉ'}")

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


class InstrumentPlug(BasePlug):
    """Remplace les VI de pilote d'instrument LabVIEW.

    setUp = équivalent de l'ouverture d'une session VISA dans LabVIEW
    méthodes = équivalent des SubVI pour chaque mesure
    tearDown = équivalent de la fermeture de session
    """

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

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

    def tearDown(self):
        pass
        # Remplacer par : self.instr.close()


@htf.measures(
    htf.Measurement("rail_3v3")
    .in_range(3.2, 3.4)
    .with_units(units.VOLT)
    .doc("Rail 3,3 V"),
    htf.Measurement("rail_5v0")
    .in_range(4.8, 5.2)
    .with_units(units.VOLT)
    .doc("Rail 5,0 V"),
)
@htf.plug(instr=InstrumentPlug)
def test_power_rails(test, instr):
    """Remplace une séquence de test LabVIEW avec des 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("Scanner le numéro de série : "))


if __name__ == "__main__":
    main()