Données de test en séries temporelles

Analyse de données de test en séries temporelles avec TofuPilot

Les tests matériels produisent des formes d'onde, pas seulement des nombres isolés. Un test d'ondulation d'alimentation capture des milliers d'échantillons de tension dans le temps. Un test de vibration enregistre des spectres d'accélération sur différentes bandes de fréquence. TofuPilot stocke ces mesures en séries temporelles nativement, vous permettant de suivre et comparer les formes d'onde sur l'ensemble de votre production.

Valeurs uniques vs. séries temporelles

La plupart des systèmes de test stockent un seul nombre par mesure : « tension de sortie = 3,31 V ». Mais l'histoire complète se trouve dans la forme d'onde. Ce 3,31 V peut être un signal DC propre ou un signal bruité qui se moyenne simplement à 3,31 V.

TofuPilot gère tous ces types grâce aux tableaux de mesure multidimensionnels.

Capture de données en séries temporelles

Avec OpenHTF

Utilisez des mesures dimensionnées pour stocker les données en séries temporelles.

import openhtf as htf
from tofupilot.openhtf import TofuPilotClient
import numpy as np

@htf.measures(
    htf.Measurement("output_ripple_mv")
        .with_dimensions("time_us")
        .with_units("mV"),
    htf.Measurement("ripple_pk_pk_mv")
        .in_range(0, 50)
        .with_units("mV"),
)
def ripple_test(test):
    # Capturer 1000 échantillons à 100 kHz (espacement de 10 us)
    waveform = capture_oscilloscope(channel=1, samples=1000, rate_hz=100000)

    for i, sample in enumerate(waveform):
        test.measurements.output_ripple_mv[i * 10] = sample  # temps en microsecondes

    # Stocker aussi le résumé scalaire
    test.measurements.ripple_pk_pk_mv = max(waveform) - min(waveform)

def main():
    test = htf.Test(ripple_test)
    test.add_output_callbacks(TofuPilotClient())
    test.execute(lambda: "PSU-2025-0099")

Avec le client Python

Passez des listes ou des tableaux directement.

from tofupilot import TofuPilotClient
import numpy as np

client = TofuPilotClient()

# Capturer la forme d'onde depuis l'oscilloscope
waveform = capture_oscilloscope(channel=1, samples=1000, rate_hz=100000)
pk_pk = float(np.max(waveform) - np.min(waveform))

client.create_run(
    procedure_id="PSU-RIPPLE-TEST",
    unit_under_test={"serial_number": "PSU-2025-0099"},
    run_passed=pk_pk < 50,
    steps=[{
        "name": "Output Ripple",
        "step_type": "measurement",
        "status": pk_pk < 50,
        "measurements": [
            {
                "name": "ripple_waveform_mv",
                "value": waveform.tolist(),
                "unit": "mV",
            },
            {
                "name": "ripple_pk_pk_mv",
                "value": pk_pk,
                "unit": "mV",
                "limit_high": 50,
            },
        ],
    }],
)

Types de données de test en séries temporelles

Formes d'onde tension/courant

Capturées depuis des oscilloscopes ou des DAQ lors de séquences de mise sous tension, tests d'ondulation ou tests de réponse transitoire. Stockez la forme d'onde brute plus les résumés scalaires (crête-à-crête, RMS, temps de montée).

Profils de température

Enregistrés pendant les cycles thermiques, le déverminage ou les tests de dissipation thermique. Plusieurs capteurs produisent des données de séries temporelles multi-canaux sur des minutes ou des heures.

# Test thermique avec 4 capteurs de température échantillonnés chaque seconde pendant 30 minutes
sensors = ["junction", "ambient", "heatsink", "case"]
duration_s = 1800
samples_per_sensor = duration_s  # 1 échantillon/seconde

for sensor_name in sensors:
    readings = read_thermal_sensor(sensor_name, samples=samples_per_sensor)
    measurements.append({
        "name": f"temp_{sensor_name}",
        "value": readings,  # liste de 1800 valeurs
        "unit": "°C",
    })

Spectres de vibration

Données FFT d'accéléromètres lors de tests de vibration. La fréquence sur un axe, l'amplitude sur l'autre.

Courbes pression/débit

Mesures de pression et de débit en séries temporelles lors de tests d'étanchéité, tests pneumatiques ou validation hydraulique.

Analyse des séries temporelles sur l'ensemble de la production

La puissance du stockage de formes d'onde (et non de simples scalaires) réside dans la comparaison entre unités.

Superposition de formes d'onde

Comparez les formes d'onde d'ondulation de 100 unités. Si 99 se ressemblent et qu'une a un pic supplémentaire, cette unité a un problème que la mesure crête-à-crête seule n'aurait peut-être pas détecté.

Bornes statistiques

Calculez la moyenne et l'écart type de votre forme d'onde à chaque point temporel sur toutes les unités. Cela vous donne une enveloppe de comportement normal. Toute unité dont la forme d'onde sort de l'enveloppe est signalée.

import numpy as np

# Toutes les formes d'onde de la production (chacune est une liste de 1000 échantillons)
all_waveforms = np.array(waveforms_from_tofupilot)  # forme : (N_unités, 1000)

mean_waveform = np.mean(all_waveforms, axis=0)
std_waveform = np.std(all_waveforms, axis=0)

upper_bound = mean_waveform + 3 * std_waveform
lower_bound = mean_waveform - 3 * std_waveform

# Vérifier si la forme d'onde d'une nouvelle unité est dans les bornes
new_waveform = np.array(new_unit_data)
is_anomalous = np.any(new_waveform > upper_bound) or np.any(new_waveform < lower_bound)

Analyse de tendance sur les caractéristiques de forme d'onde

Extrayez des caractéristiques de chaque forme d'onde (temps de montée, temps d'établissement, dépassement, RMS) et suivez leur tendance sur la production. Une augmentation progressive du temps de montée entre les unités suggère une dérive de composant ou de processus.

Bonnes pratiques