Tests HIL avec Python

import openhtf as htf
from openhtf.plugs import BasePlug


class GpioPlug(BasePlug):
    """Interface GPIO pour stimuler les entrées du DUT et lire les sorties.

    Remplacez par un vrai adaptateur GPIO (ex. LabJack, Arduino, RPi.GPIO).
    """

    def setUp(self):
        self._pin_states = {}

    def set_pin(self, pin: int, state: bool):
        """Définir une broche GPIO sur le montage de test (entrée DUT)."""
        self._pin_states[pin] = state

    def read_pin(self, pin: int) -> bool:
        """Lire une broche GPIO du DUT (sortie DUT)."""
        return self._pin_states.get(pin, False)

    def tearDown(self):
        self._pin_states.clear()


class AdcPlug(BasePlug):
    """Interface ADC pour lire les sorties analogiques du DUT.

    Remplacez par un vrai DAQ (ex. NI DAQmx, LabJack, ADS1115).
    """

    def setUp(self):
        self._channels = {0: 1.65, 1: 2.50, 2: 0.33}

    def read_channel(self, channel: int) -> float:
        """Lire la tension d'un canal ADC."""
        return self._channels.get(channel, 0.0)

    def tearDown(self):
        pass


class PwmPlug(BasePlug):
    """Interface de mesure PWM.

    Remplacez par un vrai compteur de fréquence ou oscilloscope.
    """

    def setUp(self):
        pass

    def measure_frequency(self) -> float:
        """Mesurer la fréquence de sortie PWM en Hz."""
        return 1000.0

    def measure_duty_cycle(self) -> float:
        """Mesurer le rapport cyclique PWM en pourcentage."""
        return 50.0

    def tearDown(self):
        pass

import openhtf as htf


@htf.measures(
    htf.Measurement("gpio_loopback")
    .equals(True)
    .doc("Bouclage GPIO : définir l'entrée, vérifier que la sortie suit"),
)
@htf.plug(gpio=GpioPlug)
def test_gpio_loopback(test, gpio):
    """Vérifier que le firmware route correctement l'entrée GPIO vers la sortie."""
    gpio.set_pin(1, True)  # Stimuler l'entrée du DUT
    readback = gpio.read_pin(1)  # Lire la sortie du DUT
    test.measurements.gpio_loopback = readback

import openhtf as htf
from openhtf.util import units


@htf.measures(
    htf.Measurement("adc_channel_0")
    .in_range(1.5, 1.8)
    .with_units(units.VOLT)
    .doc("ADC ch0 : tension de référence 1,65V"),
    htf.Measurement("adc_channel_1")
    .in_range(2.3, 2.7)
    .with_units(units.VOLT)
    .doc("ADC ch1 : sortie capteur 2,5V"),
)
@htf.plug(adc=AdcPlug)
def test_adc_readings(test, adc):
    """Vérifier que les canaux ADC lisent les tensions attendues."""
    test.measurements.adc_channel_0 = adc.read_channel(0)
    test.measurements.adc_channel_1 = adc.read_channel(1)

import openhtf as htf
from openhtf.util import units


@htf.measures(
    htf.Measurement("pwm_frequency")
    .in_range(950, 1050)
    .with_units(units.HERTZ)
    .doc("Fréquence de sortie PWM (cible : 1 kHz)"),
    htf.Measurement("pwm_duty_cycle")
    .in_range(48, 52)
    .doc("Rapport cyclique PWM en pourcentage (cible : 50%)"),
)
@htf.plug(pwm=PwmPlug)
def test_pwm_output(test, pwm):
    """Vérifier la fréquence et le rapport cyclique de la sortie PWM."""
    test.measurements.pwm_frequency = pwm.measure_frequency()
    test.measurements.pwm_duty_cycle = pwm.measure_duty_cycle()

import openhtf as htf
from tofupilot.openhtf import TofuPilot


def main():
    test = htf.Test(
        test_gpio_loopback,
        test_adc_readings,
        test_pwm_output,
        procedure_id="HIL-001",
        part_number="ECU-100",
    )
    with TofuPilot(test):
        test.execute(test_start=lambda: input("Version du firmware : "))


if __name__ == "__main__":
    main()