Predictive Tire Maintenance with Streaming SQL

Tire failures are among the most preventable yet costly incidents in commercial trucking. By streaming axle sensor data—tire pressure, temperature, and load distribution—through RisingWave, a PostgreSQL-compatible streaming database, fleet maintenance teams can detect abnormal patterns hours before a tire fails, scheduling replacements during planned stops rather than roadside emergencies.

Why Predictive Tire Maintenance Matters for Fleets

Commercial vehicle tires represent a significant operating expense, and blowouts carry costs far beyond tire replacement: tow truck dispatch, cargo delays, potential road debris liability, and driver safety risk. Yet most fleets still rely on visual inspections at terminals and manual pressure checks at fuel stops—reactive rather than predictive.

Modern trucks can be equipped with Tire Pressure Monitoring Systems (TPMS) and axle load sensors that stream telemetry continuously. The data tells a clear story if analyzed correctly:

• Slow pressure loss over hours indicates a puncture or valve stem failure long before it becomes a blowout
• Temperature anomalies at a specific wheel position suggest improper inflation, brake drag, or bearing issues
• Axle load imbalance reveals improper load distribution that accelerates uneven tire wear
• Vibration signatures from wheel sensors correlate with tread separation or out-of-round conditions

The challenge is that this data arrives continuously from hundreds of vehicles simultaneously, and threshold crossings in isolation may be noise. Meaningful patterns require time-series analysis across rolling windows—exactly what streaming SQL enables.

How Streaming SQL Solves This

RisingWave ingests TPMS and axle sensor streams from Kafka and maintains materialized views that continuously compute per-wheel rolling statistics. Maintenance engineers define alert thresholds in SQL; RisingWave evaluates them incrementally as each sensor reading arrives.

Unlike batch systems that run nightly tire reports, RisingWave provides:

• Continuous rolling averages of pressure and temperature per wheel position per VIN
• Anomaly detection using deviation from the vehicle's own historical baseline within the current trip
• Load imbalance scoring by comparing axle-by-axle readings in real time
• Maintenance queue integration via Kafka sinks to dispatch systems

Building the System

Step 1: Data Source

CREATE SOURCE tpms_axle_readings (
    reading_id       VARCHAR,
    vin              VARCHAR,
    event_time       TIMESTAMPTZ,
    axle_position    VARCHAR,  -- 'FRONT_LEFT','FRONT_RIGHT','REAR_LEFT_INNER','REAR_LEFT_OUTER', etc.
    tire_pressure_kpa FLOAT,
    tire_temp_c      FLOAT,
    axle_load_kg     FLOAT,
    wheel_speed_rpm  FLOAT,
    vibration_hz     FLOAT,
    tread_depth_mm   FLOAT     -- from ultrasonic sensor if equipped
)
WITH (
    connector = 'kafka',
    topic = 'fleet.tpms.readings',
    properties.bootstrap.server = 'kafka:9092',
    scan.startup.mode = 'latest'
) FORMAT PLAIN ENCODE JSON;

Step 2: Real-Time View

Compute a 30-minute rolling window of tire statistics per wheel position per vehicle. Tracking the minimum pressure in the window surfaces slow leaks that a point-in-time reading might miss.

CREATE MATERIALIZED VIEW tire_health_rolling AS
SELECT
    vin,
    axle_position,
    window_start,
    window_end,
    AVG(tire_pressure_kpa)   AS avg_pressure_kpa,
    MIN(tire_pressure_kpa)   AS min_pressure_kpa,
    MAX(tire_pressure_kpa)   AS max_pressure_kpa,
    MAX(tire_pressure_kpa) - MIN(tire_pressure_kpa) AS pressure_variance_kpa,
    AVG(tire_temp_c)         AS avg_temp_c,
    MAX(tire_temp_c)         AS max_temp_c,
    AVG(axle_load_kg)        AS avg_axle_load_kg,
    AVG(vibration_hz)        AS avg_vibration_hz,
    MAX(vibration_hz)        AS max_vibration_hz,
    COUNT(*)                 AS reading_count
FROM TUMBLE(
    tpms_axle_readings,
    event_time,
    INTERVAL '30 minutes'
)
GROUP BY vin, axle_position, window_start, window_end;

Detect axle load imbalance by comparing load readings across positions in the same window:

CREATE MATERIALIZED VIEW axle_load_balance AS
SELECT
    vin,
    window_start,
    window_end,
    MAX(avg_axle_load_kg) - MIN(avg_axle_load_kg) AS load_imbalance_kg,
    COUNT(DISTINCT axle_position)                  AS axle_positions_reporting
FROM tire_health_rolling
GROUP BY vin, window_start, window_end
HAVING COUNT(DISTINCT axle_position) >= 4;

Step 3: Alerts

Generate maintenance alerts for tires showing critical pressure loss, thermal anomalies, or high vibration. Route these to the dispatch system so maintenance can be scheduled at the next terminal stop.

CREATE MATERIALIZED VIEW tire_maintenance_alerts AS
SELECT
    vin,
    axle_position,
    window_start,
    window_end,
    avg_pressure_kpa,
    min_pressure_kpa,
    max_temp_c,
    pressure_variance_kpa,
    max_vibration_hz,
    CASE
        WHEN min_pressure_kpa < 620                   THEN 'LOW_PRESSURE_CRITICAL'
        WHEN pressure_variance_kpa > 40               THEN 'PRESSURE_LOSS_DETECTED'
        WHEN max_temp_c > 90                          THEN 'THERMAL_ANOMALY'
        WHEN max_vibration_hz > 150                   THEN 'VIBRATION_ALERT'
        ELSE 'NORMAL'
    END AS alert_type
FROM tire_health_rolling
WHERE min_pressure_kpa < 620
   OR pressure_variance_kpa > 40
   OR max_temp_c > 90
   OR max_vibration_hz > 150;

CREATE SINK tire_alerts_sink
FROM tire_maintenance_alerts
WITH (
    connector = 'kafka',
    topic = 'fleet.tire.maintenance.alerts',
    properties.bootstrap.server = 'kafka:9092'
) FORMAT PLAIN ENCODE JSON;

Comparison Table

FAQ

Q: How do I set pressure thresholds that account for different tire sizes and load ratings across my mixed fleet? Join tpms_axle_readings against a vehicle-tire reference table that maps VIN and axle position to tire specifications. Your materialized view can then use per-vehicle thresholds from the join rather than global constants.

Q: Can RisingWave detect gradual pressure loss that unfolds over a full trip of several hours? Yes. You can configure sliding windows (using the HOP function) with a longer window duration and shorter slide interval—for example, a 4-hour window sliding every 30 minutes. This allows the view to track pressure trends across the full trip while remaining sensitive to recent changes.

Q: What sensor hardware is required to implement this? This architecture requires TPMS sensors on each wheel and optionally axle load cells and wheel vibration sensors. Many modern commercial trucks come with TPMS from the factory; aftermarket solutions from vendors in the fleet telematics space can add this capability to older vehicles.

Key Takeaways

• TPMS and axle sensor data contains predictive signals for tire failure that are only actionable when analyzed as time-series trends, not point-in-time readings.
• RisingWave's rolling window aggregations over per-wheel sensor streams detect slow pressure loss and temperature anomalies hours before they become critical.
• Load imbalance detection across axle positions surfaces cargo distribution problems that accelerate uneven tire wear without any additional sensors.
• Streaming SQL lets maintenance engineers express predictive logic in familiar SQL, routing alerts to dispatch systems via Kafka for same-stop intervention.

Get started | Slack