HIL Testing with Python

import openhtf as htf
from openhtf.plugs import BasePlug


class GpioPlug(BasePlug):
    """GPIO interface for stimulating DUT inputs and reading outputs.

    Replace with real GPIO adapter (e.g., LabJack, Arduino, RPi.GPIO).
    """

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

    def set_pin(self, pin: int, state: bool):
        """Set a GPIO pin on the test fixture (DUT input)."""
        self._pin_states[pin] = state

    def read_pin(self, pin: int) -> bool:
        """Read a GPIO pin from the DUT (DUT output)."""
        return self._pin_states.get(pin, False)

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


class AdcPlug(BasePlug):
    """ADC interface for reading analog outputs from DUT.

    Replace with real DAQ (e.g., 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:
        """Read an ADC channel voltage."""
        return self._channels.get(channel, 0.0)

    def tearDown(self):
        pass


class PwmPlug(BasePlug):
    """PWM measurement interface.

    Replace with real frequency counter or oscilloscope.
    """

    def setUp(self):
        pass

    def measure_frequency(self) -> float:
        """Measure PWM output frequency in Hz."""
        return 1000.0

    def measure_duty_cycle(self) -> float:
        """Measure PWM duty cycle in percent."""
        return 50.0

    def tearDown(self):
        pass

import openhtf as htf


@htf.measures(
    htf.Measurement("gpio_loopback")
    .equals(True)
    .doc("GPIO pin loopback: set input, verify output follows"),
)
@htf.plug(gpio=GpioPlug)
def test_gpio_loopback(test, gpio):
    """Verify firmware routes GPIO input to output correctly."""
    gpio.set_pin(1, True)  # Stimulate DUT input
    readback = gpio.read_pin(1)  # Read DUT output
    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: 1.65V reference voltage"),
    htf.Measurement("adc_channel_1")
    .in_range(2.3, 2.7)
    .with_units(units.VOLT)
    .doc("ADC ch1: 2.5V sensor output"),
)
@htf.plug(adc=AdcPlug)
def test_adc_readings(test, adc):
    """Verify ADC channels read expected voltages."""
    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("PWM output frequency (target: 1kHz)"),
    htf.Measurement("pwm_duty_cycle")
    .in_range(48, 52)
    .doc("PWM duty cycle percentage (target: 50%)"),
)
@htf.plug(pwm=PwmPlug)
def test_pwm_output(test, pwm):
    """Verify PWM output frequency and duty cycle."""
    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("Firmware version: "))


if __name__ == "__main__":
    main()