Convertir datos de ensayos automotrices entre km/h, m/s, g y m/s²

01Escribir las reglas de conversión antes de tocar los datos

Este ejemplo estandariza la velocidad a metres per second y la aceleración a metres per second squared. La conversión de velocidad se basa en 1 kilometre = 1000 metres y 1 hour = 3600 seconds, por lo que km/h se divide entre 3.6 para obtener m/s. La conversión inversa multiplica m/s por 3.6.

Para la aceleración, este tutorial utiliza el conventional standard gravity value g0 = 9.80665 m/s². Un valor expresado en g se multiplica por 9.80665 para obtener m/s². La conversión inversa divide m/s² entre 9.80665.

02Crear un pequeño conjunto sintético de datos de ensayo

El dataset siguiente es sintético y fue creado específicamente para este artículo. Guárdalo como unit_test_data.csv. Los valores se eligieron para que las conversiones de velocidad sean fáciles de verificar manualmente, mientras que los ejemplos de aceleración incluyen valores de g positivos, negativos y fraccionarios.

sample_id,speed_kmh,accel_g
T001,0,0
T002,36,1
T003,72,-0.5
T004,90,0.25
T005,108,-1.25

Hay 5 registros. Los negative acceleration values se conservan como valores negativos; la conversión cambia la unidad, no el signo. Este dataset es únicamente un ejemplo numérico y no pretende representar una vehicle manoeuvre ni un sensor específicos.

03Calcular manualmente los valores esperados

Las conversiones de velocidad son directas. Por ejemplo, 72 km/h ÷ 3.6 = 20 m/s y 90 km/h ÷ 3.6 = 25 m/s. Al convertir de vuelta se obtiene 20 × 3.6 = 72 km/h y 25 × 3.6 = 90 km/h.

Para la aceleración, 1 g se convierte en 9.80665 m/s². Un valor de -0.5 g se convierte en -4.903325 m/s². Un valor de 0.25 g se convierte en 2.4516625 m/s². Un valor de -1.25 g se convierte en -12.2583125 m/s².

Los acceleration values mostrados están redondeados a seis decimales. El cálculo debe utilizar el factor completo 9.80665 en lugar de reutilizar repetidamente el output text ya redondeado.

04Convertir el CSV y realizar comprobaciones de ida y vuelta

Guarda el script siguiente como unit_conversion_check.py. Lee los values originales, realiza ambas forward conversions, convierte los resultados de vuelta a las units originales y comprueba el round trip con una pequeña numerical tolerance. El CSV original nunca se reescribe.

import csv
import math
from pathlib import Path

SOURCE = Path("unit_test_data.csv")
OUTPUT_DIR = Path("outputs") / "unit_conversion_result"
OUTPUT = OUTPUT_DIR / "converted_test_data.csv"
STANDARD_GRAVITY = 9.80665
TOLERANCE = 1e-12


def kmh_to_ms(value: float) -> float:
    return value / 3.6


def ms_to_kmh(value: float) -> float:
    return value * 3.6


def g_to_ms2(value: float) -> float:
    return value * STANDARD_GRAVITY


def ms2_to_g(value: float) -> float:
    return value / STANDARD_GRAVITY


def main() -> None:
    if not SOURCE.is_file():
        raise FileNotFoundError(f"Source CSV not found: {SOURCE}")
    if OUTPUT_DIR.exists():
        raise FileExistsError(f"Output folder already exists: {OUTPUT_DIR}")

    output_rows = []
    with SOURCE.open("r", encoding="utf-8-sig", newline="") as stream:
        reader = csv.DictReader(stream)
        required = {"sample_id", "speed_kmh", "accel_g"}
        if reader.fieldnames is None or not required.issubset(reader.fieldnames):
            raise ValueError("CSV is missing a required column.")

        seen_ids = set()
        for row in reader:
            sample_id = row["sample_id"].strip()
            if not sample_id:
                raise ValueError("sample_id must not be blank.")
            if sample_id in seen_ids:
                raise ValueError(f"Duplicate sample_id: {sample_id}")
            seen_ids.add(sample_id)

            speed_kmh = float(row["speed_kmh"])
            accel_g = float(row["accel_g"])
            speed_ms = kmh_to_ms(speed_kmh)
            accel_ms2 = g_to_ms2(accel_g)
            speed_roundtrip = ms_to_kmh(speed_ms)
            accel_roundtrip = ms2_to_g(accel_ms2)

            speed_ok = math.isclose(
                speed_kmh, speed_roundtrip,
                rel_tol=TOLERANCE, abs_tol=TOLERANCE
            )
            accel_ok = math.isclose(
                accel_g, accel_roundtrip,
                rel_tol=TOLERANCE, abs_tol=TOLERANCE
            )
            if not speed_ok or not accel_ok:
                raise RuntimeError(f"Round-trip check failed: {sample_id}")

            output_rows.append({
                "sample_id": sample_id,
                "speed_kmh": f"{speed_kmh:g}",
                "speed_m_s": f"{speed_ms:.6f}",
                "speed_roundtrip_kmh": f"{speed_roundtrip:.6f}",
                "accel_g": f"{accel_g:g}",
                "accel_m_s2": f"{accel_ms2:.6f}",
                "accel_roundtrip_g": f"{accel_roundtrip:.6f}",
                "roundtrip_check": "PASS",
            })

    OUTPUT_DIR.parent.mkdir(parents=True, exist_ok=True)
    OUTPUT_DIR.mkdir()
    fields = [
        "sample_id", "speed_kmh", "speed_m_s", "speed_roundtrip_kmh",
        "accel_g", "accel_m_s2", "accel_roundtrip_g", "roundtrip_check"
    ]
    with OUTPUT.open("x", encoding="utf-8", newline="") as stream:
        writer = csv.DictWriter(stream, fieldnames=fields)
        writer.writeheader()
        writer.writerows(output_rows)

    print(f"Converted records: {len(output_rows)}.")
    print(f"Round-trip checks passed: {len(output_rows)}.")
    print(f"Standard gravity used: {STANDARD_GRAVITY} m/s^2.")
    print(f"Output: {OUTPUT.as_posix()}")


if __name__ == "__main__":
    main()

05Comparar el archivo convertido esperado

Cada fila debería volver a su velocidad y aceleración originales después de la reverse conversion. La salida a seis decimales se muestra a continuación. Los internal calculations utilizan floating-point values antes del formatting.

sample_id,speed_kmh,speed_m_s,speed_roundtrip_kmh,accel_g,accel_m_s2,accel_roundtrip_g,roundtrip_check
T001,0,0.000000,0.000000,0,0.000000,0.000000,PASS
T002,36,10.000000,36.000000,1,9.806650,1.000000,PASS
T003,72,20.000000,72.000000,-0.5,-4.903325,-0.500000,PASS
T004,90,25.000000,90.000000,0.25,2.451663,0.250000,PASS
T005,108,30.000000,108.000000,-1.25,-12.258313,-1.250000,PASS

El console text esperado que aparece a continuación se obtuvo manualmente a partir de los datos sintéticos y del script. No es un execution log capturado.

Converted records: 5.
Round-trip checks passed: 5.
Standard gravity used: 9.80665 m/s^2.
Output: outputs/unit_conversion_result/converted_test_data.csv

06Realizar comprobaciones independientes y reconocer errores comunes

• Comprueba manualmente 36 km/h: 36 ÷ 3.6 = 10 m/s.
• Comprueba manualmente 108 km/h: 108 ÷ 3.6 = 30 m/s.
• Comprueba manualmente -0.5 g: -0.5 × 9.80665 = -4.903325 m/s².
• Confirma que los signos permanezcan sin cambios durante la unit conversion.
• Confirma que las cinco filas muestren PASS en roundtrip_check.
• Ejecuta de nuevo el script sin cambiar OUTPUT_DIR. Debería detenerse con FileExistsError en lugar de sustituir el resultado.

07Comprender los límites antes de utilizar datos reales de ensayo

Una unit conversion satisfactoria solo demuestra que la aritmética y las declared units son internamente coherentes. No demuestra que el sensor channel original estuviera calibrado correctamente, que la unit label fuera correcta ni que el recorded value represente la physical quantity que crees.

La conversión de g utiliza conventional standard gravity, 9.80665 m/s². La local gravitational acceleration puede diferir de esa conventional reference. En muchos engineering datasets, g se utiliza como normalized acceleration unit, por lo que debe documentarse la convention declarada.

Los vehicle test datasets reales también pueden mezclar wheel speed, vehicle speed, rotational speed, force, pressure y temperature units. Crea un data dictionary y convierte cada channel según su physical dimension. Nunca deduzcas una unit únicamente por la magnitude de los números.

Registro de ejecución y verificación

2026-09-20 · ejemplo revisado manualmente · objetivo: Python 3.12 · biblioteca estándar: csv, math, pathlib · sin ejecución

• Se convirtieron manualmente las cinco velocidades a 0, 10, 20, 25 y 30 m/s.
• Se calcularon manualmente los acceleration values utilizando 9.80665 m/s² por g.
• Se comprobaron -0.5 g como -4.903325 m/s², 0.25 g como 2.4516625 m/s² y -1.25 g como -12.2583125 m/s² antes del redondeo de visualización.
• Se comprobaron manualmente las reverse speed conversions multiplicando por 3.6.
• Se revisó el código para required columns, duplicate sample IDs, round-trip comparisons, output collision protection y conservación del CSV original.
• Se obtuvieron manualmente el CSV esperado y la salida de consola.

Criterios de redacción y verificación de todo el sitio

Fuentes de referencia

Las explicaciones y los ejemplos son de elaboración propia. Puedes consultar los comportamientos y conceptos relacionados en las siguientes fuentes oficiales.

• BIPM · Folleto del Sistema Internacional de Unidades SI ↗ (New tab)
• Documentación oficial de Python 3.12 · math ↗ (New tab)
• Documentación oficial de Python 3.12 · csv ↗ (New tab)
• Documentación oficial de Python 3.12 · pathlib ↗ (New tab)