Converta dados de testes automotivos entre km/h, m/s, g e m/s²

01Escreva as regras de conversão antes de mexer nos dados

Este exemplo padroniza a velocidade para metres per second e a aceleração para metres per second squared. A conversão de velocidade se baseia em 1 kilometre = 1000 metres e 1 hour = 3600 seconds, portanto km/h é dividido por 3.6 para obter m/s. A conversão inversa multiplica m/s por 3.6.

Para aceleração, este tutorial usa o conventional standard gravity value g0 = 9.80665 m/s². Um valor expresso em g é multiplicado por 9.80665 para obter m/s². A conversão inversa divide m/s² por 9.80665.

02Crie um pequeno conjunto sintético de dados de teste

O dataset a seguir é sintético e foi criado especificamente para este artigo. Salve-o como unit_test_data.csv. Os valores foram escolhidos para que as conversões de velocidade sejam fáceis de verificar manualmente, enquanto os exemplos de aceleração incluem valores de g positivos, negativos e fracionários.

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

Há 5 registros. Negative acceleration values são preservados como valores negativos; a conversão altera a unidade, não o sinal. Este dataset é apenas um exemplo numérico e não pretende representar uma vehicle manoeuvre ou sensor específico.

03Calcule manualmente os valores esperados

As conversões de velocidade são diretas. Por exemplo, 72 km/h ÷ 3.6 = 20 m/s e 90 km/h ÷ 3.6 = 25 m/s. Convertendo de volta, temos 20 × 3.6 = 72 km/h e 25 × 3.6 = 90 km/h.

Para aceleração, 1 g se torna 9.80665 m/s². Um valor de -0.5 g se torna -4.903325 m/s². Um valor de 0.25 g se torna 2.4516625 m/s². Um valor de -1.25 g se torna -12.2583125 m/s².

Os acceleration values exibidos são arredondados para seis casas decimais. O cálculo em si deve usar o fator completo 9.80665 em vez de reutilizar repetidamente o output text já arredondado.

04Converta o CSV e faça verificações de ida e volta

Salve o script a seguir como unit_conversion_check.py. Ele lê os values originais, realiza ambas as forward conversions, converte os resultados de volta para as units originais e verifica o round trip com uma pequena numerical tolerance. O CSV original nunca é regravado.

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()

05Compare o arquivo convertido esperado

Cada linha deve retornar à velocidade e aceleração originais após a reverse conversion. A saída com seis casas decimais é mostrada abaixo. Os internal calculations usam floating-point values antes da formatação.

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

O console text esperado abaixo foi derivado manualmente a partir dos dados sintéticos e do script. Não é um 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

06Faça verificações independentes e reconheça erros comuns

• Verifique manualmente 36 km/h: 36 ÷ 3.6 = 10 m/s.
• Verifique manualmente 108 km/h: 108 ÷ 3.6 = 30 m/s.
• Verifique manualmente -0.5 g: -0.5 × 9.80665 = -4.903325 m/s².
• Confirme que os sinais permanecem inalterados durante a unit conversion.
• Confirme que todas as cinco linhas mostram PASS em roundtrip_check.
• Execute o script novamente sem alterar OUTPUT_DIR. Ele deve parar com FileExistsError em vez de substituir o resultado.

07Entenda os limites antes de usar dados reais de teste

Uma unit conversion bem-sucedida mostra apenas que a aritmética e as declared units são internamente consistentes. Ela não prova que o sensor channel original foi calibrado corretamente, que a unit label estava correta nem que o recorded value representa a physical quantity que você imagina.

A conversão de g aqui usa conventional standard gravity, 9.80665 m/s². A local gravitational acceleration pode diferir dessa conventional reference. Em muitos engineering datasets, g é usado como normalized acceleration unit, portanto a convention declarada deve ser documentada.

Vehicle test datasets reais também podem misturar wheel speed, vehicle speed, rotational speed, force, pressure e temperature units. Crie um data dictionary e converta cada channel de acordo com sua physical dimension. Nunca deduza uma unit apenas pela magnitude dos números.

Registro de execução e verificação

2026-09-20 · exemplo verificado manualmente · alvo: Python 3.12 · biblioteca padrão: csv, math, pathlib · sem execução

• Foram convertidas manualmente as cinco velocidades para 0, 10, 20, 25 e 30 m/s.
• Foram calculados manualmente os acceleration values usando 9.80665 m/s² por g.
• Foram verificados -0.5 g como -4.903325 m/s², 0.25 g como 2.4516625 m/s² e -1.25 g como -12.2583125 m/s² antes do arredondamento de exibição.
• Foram verificadas manualmente as reverse speed conversions multiplicando por 3.6.
• O código foi inspecionado quanto a required columns, duplicate sample IDs, round-trip comparisons, output collision protection e preservação do CSV original.
• O CSV esperado e a saída do console foram derivados manualmente.

Princípios de redação e verificação de todo o site

Fontes de referência

As explicações e os exemplos são de elaboração própria. Os comportamentos e conceitos relacionados podem ser consultados nas fontes oficiais abaixo.

• BIPM · Brochura do Sistema Internacional de Unidades SI ↗ (New tab)
• Documentação oficial do Python 3.12 · math ↗ (New tab)
• Documentação oficial do Python 3.12 · csv ↗ (New tab)
• Documentação oficial do Python 3.12 · pathlib ↗ (New tab)