Suivre les versions firmware production

Quand une unité tombe en panne sur le terrain, la première question est « quel firmware tournait-elle ? » Si vous ne pouvez pas répondre à partir de vos enregistrements de test, vous êtes réduit à deviner. TofuPilot vous permet de taguer chaque exécution de test avec la version du firmware afin de pouvoir filtrer, tracer et rapporter dessus ultérieurement.

Pourquoi le suivi de version firmware est important

Les changements de firmware entre les lots de production sont fréquents. Un correctif dans la v2.4.2 pourrait introduire une régression qui ne se manifeste que dans des conditions spécifiques. Sans suivi de version, vous ne pouvez pas corréler les pics de défaillance avec les mises à jour firmware.

Les normes réglementaires (IEC 62304, FDA 21 CFR Part 820, ISO 13485) exigent que vous documentiez la configuration logicielle de chaque dispositif au moment de la production. Pour les retours terrain, vous devez prouver quel firmware était chargé quand l'unité a quitté votre usine.

Le suivi firmware aide également lors des transitions EVT/DVT/PVT. Vous pouvez comparer le FPY et les distributions de mesures entre les versions firmware pour vérifier qu'un nouveau build ne dégrade pas les performances.

Enregistrer la version firmware comme mesure

L'approche la plus simple est d'enregistrer la version firmware comme mesure dans votre test. Cela la rend visible dans chaque enregistrement d'exécution.

import openhtf as htf
from tofupilot.openhtf import TofuPilot

@htf.measures(
    htf.Measurement("firmware_version"),
    htf.Measurement("boot_time")
    .in_range(maximum=2000),
    htf.Measurement("self_test_pass")
    .equals(True),
)
def boot_validation(test):
    test.measurements.firmware_version = "3.1.0-rc2"
    test.measurements.boot_time = 843
    test.measurements.self_test_pass = True

@htf.measures(
    htf.Measurement("ble_rssi")
    .in_range(minimum=-70, maximum=-20),
    htf.Measurement("wifi_throughput")
    .in_range(minimum=50.0),
)
def wireless_check(test):
    test.measurements.ble_rssi = -42
    test.measurements.wifi_throughput = 87.3

def main():
    test = htf.Test(
        boot_validation,
        wireless_check,
        station_id="STATION-FT-04",
    )
    with TofuPilot(test):
        test.execute(test_start=lambda: "HUB-2026-03-00891")

if __name__ == "__main__":
    main()

Chaque exécution dans TofuPilot portera la version firmware comme champ consultable. Vous pouvez filtrer votre historique d'exécutions par cette valeur directement depuis le tableau de bord.

Lire la version firmware depuis le DUT

En production, vous ne devez pas coder en dur la version firmware. Lisez-la depuis le dispositif pendant le test pour que l'enregistrement reflète toujours ce qui est réellement sur l'unité.

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

class DeviceConnection(BasePlug):
    """Se connecte au DUT via le port série pour lire les informations du dispositif."""

    def read_firmware_version(self):
        # Remplacer par votre communication réelle avec le dispositif
        # par ex. envoyer une commande AT, lire l'UART, interroger le descripteur USB
        return "3.1.0-rc2"

    def read_bootloader_version(self):
        return "1.2.0"

    def tearDown(self):
        pass

@htf.measures(
    htf.Measurement("firmware_version"),
    htf.Measurement("bootloader_version"),
)
@htf.plug(device=DeviceConnection)
def read_device_info(test, device):
    fw = device.read_firmware_version()
    bl = device.read_bootloader_version()
    test.measurements.firmware_version = fw
    test.measurements.bootloader_version = bl

@htf.measures(
    htf.Measurement("adc_accuracy_percent")
    .in_range(maximum=0.5),
    htf.Measurement("watchdog_recovery_pass")
    .equals(True),
)
def functional_test(test):
    test.measurements.adc_accuracy_percent = 0.12
    test.measurements.watchdog_recovery_pass = True

def main():
    test = htf.Test(
        read_device_info,
        functional_test,
        station_id="STATION-FT-01",
    )
    with TofuPilot(test):
        test.execute(test_start=lambda: "SENS-2026-04217")

if __name__ == "__main__":
    main()

Cette approche enregistre la version firmware comme mesure (visible dans le détail de l'exécution) et garantit que TofuPilot capture exactement ce qui était sur le dispositif, pas ce que vous pensiez y trouver.

Filtrer les exécutions par version firmware

Une fois que vos exécutions portent les données de version firmware, le tableau de bord de TofuPilot vous permet de filtrer dessus. C'est là que le suivi prend toute sa valeur.

Investigation de défaillance. Filtrez les exécutions sur une version firmware spécifique et vérifiez le FPY. Si la v3.1.0-rc2 a un rendement plus bas que la v3.0.9, vous avez trouvé votre suspect.

Preuve réglementaire. Lors d'un audit, filtrez par version firmware pour montrer que toutes les unités expédiées avaient la version validée. Exportez la vue filtrée comme preuve.

Corrélation des retours terrain. Quand un client signale une défaillance, recherchez le numéro de série de l'unité, trouvez la version firmware dans l'enregistrement de test et vérifiez si d'autres unités avec le même firmware présentent un comportement similaire.

Que suivre au-delà du firmware

La version firmware est la plus critique, mais envisagez de suivre d'autres données logicielles et de configuration qui affectent les résultats de test.

Enregistrez-les comme mesures dans vos phases de test pour qu'ils soient stockés avec chaque exécution dans TofuPilot.