How to align GPS timestamps across mixed OBD-II and mobile devices

Aligning GPS timestamps from OBD-II dongles and mobile devices is a concrete sub-problem within timestamp synchronization for multi-device GPS logs. The two device classes produce structurally incompatible time series: OBD-II units carry free-running RTC chips that drift 1–5 seconds per day, while mobile location services maintain sub-100 ms accuracy through continuous NTP discipline but emit points at irregular, battery-optimized intervals. Naively merging the two streams produces phantom route segments, artificial speed spikes, and broken stop detection events. The solution is a four-stage deterministic pipeline: UTC normalization → overlap trimming → common-grid resampling → time-aware interpolation.

The diagram below shows how the raw device streams converge at each stage.

Compatibility & configuration requirements

The function below also preserves any extra numeric columns (e.g. speed_kmh, accuracy_hdop) through time-aware interpolation, so calling code does not need to strip them first.

Production-ready implementation

import pandas as pd
import numpy as np
from typing import Tuple


def align_gps_timestamps(
    obd_df: pd.DataFrame,
    mobile_df: pd.DataFrame,
    freq: str = "1s",
    max_gap_threshold: int = 30,
) -> Tuple[pd.DataFrame, pd.DataFrame]:
    """
    Align OBD-II and mobile GPS logs to a shared UTC temporal grid.

    Parameters
    ----------
    obd_df : pd.DataFrame
        Raw OBD-II log. Must contain 'timestamp' (tz-aware UTC), 'lat', 'lon'.
        Any additional numeric columns (speed, hdop) are interpolated alongside.
    mobile_df : pd.DataFrame
        Raw mobile location log. Same schema requirements as obd_df.
    freq : str
        Target grid frequency in pandas offset alias format ('1s', '5s', '10s').
        Use lowercase aliases — uppercase 'S' is deprecated in pandas >= 2.2.
    max_gap_threshold : int
        Maximum seconds between consecutive original readings before a grid point
        is flagged as low-confidence in the 'is_gap' output column.

    Returns
    -------
    Tuple[pd.DataFrame, pd.DataFrame]
        (obd_aligned, mobile_aligned) — both on the same DatetimeIndex, UTC,
        with numeric columns interpolated and an 'is_gap' boolean column appended.

    Raises
    ------
    ValueError
        If either DataFrame contains timezone-naive timestamps, or if the two
        streams have no temporal overlap after trimming.
    """
    # ------------------------------------------------------------------ #
    # Stage 1: Parse & localize to UTC                                    #
    # ------------------------------------------------------------------ #
    processed = []
    for label, df in (("obd", obd_df), ("mobile", mobile_df)):
        df = df.copy()

        # Convert whatever format the 'timestamp' column holds to UTC-aware datetimes.
        # utc=True coerces tz-aware strings/epoch-ms correctly; it does NOT silently
        # assume local time for naive strings — those raise an AmbiguousTimeError,
        # which is the desired behaviour so callers fix the source data.
        df["timestamp"] = pd.to_datetime(df["timestamp"], utc=True)

        if df["timestamp"].dt.tz is None:
            raise ValueError(
                f"[{label}] Timestamps must be timezone-aware. "
                "Localize to UTC before calling align_gps_timestamps()."
            )

        df = df.set_index("timestamp").sort_index()
        processed.append(df)

    obd_utc, mobile_utc = processed

    # ------------------------------------------------------------------ #
    # Stage 2: Trim to the temporal intersection                          #
    # ------------------------------------------------------------------ #
    # Extrapolating beyond either stream's real observations produces     #
    # coordinates that are mathematically valid but physically meaningless.
    start = max(obd_utc.index.min(), mobile_utc.index.min())
    end = min(obd_utc.index.max(), mobile_utc.index.max())

    if start >= end:
        raise ValueError(
            "No temporal overlap between OBD-II and mobile streams. "
            "Check that both DataFrames cover the same trip window in UTC."
        )

    obd_trimmed = obd_utc.loc[start:end].copy()
    mobile_trimmed = mobile_utc.loc[start:end].copy()

    # ------------------------------------------------------------------ #
    # Stage 3: Resample to a uniform common grid                          #
    # ------------------------------------------------------------------ #
    # pd.date_range produces a deterministic sequence of UTC timestamps.  #
    # reindex() places existing rows on the nearest grid point and leaves  #
    # NaN for grid points with no matching observation — ready for interp. #
    common_grid = pd.date_range(start=start, end=end, freq=freq, tz="UTC")

    obd_resampled = obd_trimmed.reindex(common_grid)
    mobile_resampled = mobile_trimmed.reindex(common_grid)

    # ------------------------------------------------------------------ #
    # Stage 4: Time-aware interpolation & gap flagging                    #
    # ------------------------------------------------------------------ #
    for df in (obd_resampled, mobile_resampled):
        numeric_cols = df.select_dtypes(include="number").columns

        # method="time" weights each fill point by actual elapsed seconds,
        # not by positional index distance. This matters when original points
        # are irregularly spaced — as mobile data almost always is.
        df[numeric_cols] = df[numeric_cols].interpolate(
            method="time",
            limit_direction="both",
        )

        # Mark any grid point that falls in a data gap longer than the threshold.
        # Downstream analytics (stop detection, speed profiling) can filter or
        # discount these rows rather than treating interpolated coords as real fixes.
        time_diffs = df.index.to_series().diff().dt.total_seconds()
        df["is_gap"] = time_diffs > max_gap_threshold

        # The very first row has no predecessor diff; it is not a gap.
        if len(df) > 0:
            df.iloc[0, df.columns.get_loc("is_gap")] = False

    return obd_resampled, mobile_resampled

Execution & tuning guidelines

Running the function requires both DataFrames to have their timestamp column already localized to UTC. A minimal call looks like:

obd_aligned, mobile_aligned = align_gps_timestamps(
    obd_df=raw_obd,
    mobile_df=raw_mobile,
    freq="1s",
    max_gap_threshold=30,
)

# Merge for downstream analytics (stop detection, map matching, speed profiling)
merged = obd_aligned.join(
    mobile_aligned,
    how="inner",
    lsuffix="_obd",
    rsuffix="_mob",
)
# Drop rows flagged as low-confidence gaps in either stream
merged = merged.loc[~merged["is_gap_obd"] & ~merged["is_gap_mob"]]

Key parameter knobs and their effects:

• freq controls the output grid spacing. Decreasing it from "5s" to "1s" raises memory usage by 5× but is required if stop detection needs to resolve dwell events shorter than 10 seconds. Increasing it toward "30s" matches sparse mobile-SDK batch intervals but loses the fine-grained positional density that DBSCAN stop clustering relies on.

• max_gap_threshold sets the minimum gap length (in seconds) that earns a row the is_gap = True flag. For urban fleet delivery routes, 30–60 s is typical (short gaps are normal at red lights). For ADAS or high-frequency OBD logging at 10 Hz, lower this to 2–5 s. If you also run Kalman filtering for GPS noise reduction, set the gap threshold before the filter pass, not after — the filter will smooth away the evidence of gaps.

Validation checks to run after alignment:

• Confirm obd_aligned.index.is_monotonic_increasing and mobile_aligned.index.is_monotonic_increasing both return True. Out-of-order timestamps in the input — a symptom of outlier removal in raw telematics streams skipping the sort step — will silently corrupt method="time" interpolation.
• After interpolation, verify lat values stay within [-90, 90] and lon within [-180, 180]. Interpolation across the antimeridian (lon wrapping ±180) produces nonsensical paths; handle this by projecting to a local CRS before aligning if your routes cross the antimeridian.
• Check merged["is_gap_obd"].sum() / len(merged) and the equivalent for mobile. If more than 15 % of rows are gap-flagged, the freq is likely finer than the sparser device’s native cadence and you are filling mostly synthetic data.

Related

• Up to cluster: Timestamp Synchronization for Multi-Device GPS Logs
• Up to section: GPS Data Preprocessing & Cleaning Fundamentals
• Kalman Filtering for GPS Noise Reduction — apply after timestamp alignment to smooth the merged coordinate stream
• Outlier Removal in Raw Telematics Streams — remove speed-spike and coordinate-jump outliers before resampling
• DBSCAN for Fleet Stop Clustering — relies on a temporally aligned, uniform-grid input to produce stable cluster boundaries