Why Streaming Data Is Essential for Physical AI on NXP S32 Platforms

ITTIA DB Platform Turns S32 Real-Time Data Streams into Context, Intelligence, and Physical Action

Physical AI systems built on NXP S32 platforms operate in environments where conditions change continuously, and decisions often need to happen immediately. Vehicle and industrial sensors constantly generate data related to current, voltage, temperature, vibration, pressure, RPM, battery behavior, motion, position, CAN signals, and other operating conditions. 

For S32-based ECUs, gateways, domain controllers, and intelligent edge systems to understand and act on this information, they need more than storage. They need a continuous data pipeline capable of processing what is happening now while preserving the historical context of what happened before. This is where streaming becomes essential. 

Streaming Gives S32 Physical AI Real-Time Awareness 

An S32-based Physical AI system cannot wait until all data has been collected before processing begins. Information from vehicle networks, sensors, controllers, and intelligent subsystems must be continuously received, evaluated, transformed, and prepared for analytics or AI inference. A practical data journey architecture may look like: 

  • Vehicle & Device Sensors 
  • NXP S32 
  • ITTIA DB Streaming 
  • Windowing & Filtering 
  • Feature Processing 
  • Historical Context 
  • AI Inference 
  • Decision 
  • Vehicle/Physical Action 

The stream engine becomes the real-time data path connecting physical-world observations to intelligence. On S32 platforms, this is particularly valuable because applications may need to combine real-time control, communications, data processing, persistence, diagnostics, and AI workloads within the same architecture. 

A Stream Engine Does More Than Move S32 Data 

Streaming is not simply transferring CAN messages or sensor samples from one buffer to another. For Physical AI, the streaming layer must participate directly in understanding the data. An intelligent S32 streaming pipeline may need to: 

  • Ingest Multiple Data Streams 
    Collect continuous information from CAN, vehicle sensors, battery systems, motors, thermal systems, accelerometers, acoustic sensors, and other physical sources. 
  • Filter and Clean Incoming Data 
    Remove invalid, redundant, noisy, or unnecessary measurements before they consume processing and storage resources. 
  • Create Processing Windows 
    Organize data into sliding, rolling, tumbling, or event-driven windows suitable for analytics and AI. 
  • Synchronize Multimodal Data 
    Align current, voltage, temperature, vibration, RPM, motion, position, and other measurements according to timestamps and operating conditions. 
  • Generate AI-Ready Features 
    Calculate RMS, variance, rate of change, rolling statistics, FFT components, frequency-band information, and other derived features. 
  • Manage Overload and Backpressure 
    Control incoming streams when data rates temporarily exceed available processing or storage capacity. 
  • Trigger Event-Based Retention 
    Preserve high-resolution data surrounding anomalies, vehicle faults, battery events, or other important operating conditions. 

These capabilities help transform raw S32 data streams into useful information for Edge AI and Physical AI. Physical AI on S32 Needs Both Real-Time Awareness and Historical Memory. 

Streaming answers an essential question for Physical AI: What is happening now? But intelligent automotive and industrial systems must also understand what happened before. A traction motor may gradually develop abnormal vibration, battery characteristics may change across hundreds of charge and discharge cycles, thermal behavior may slowly drift outside normal patterns, and a vehicle subsystem may experience intermittent failures only under specific combinations of load, temperature, and operating state. This is why streaming and historical data management must work together.  

The ITTIA DB Platform provides a common data foundation for S32 architectures, bringing together real-time streams, time-series history, transactional data, operating states, diagnostics, AI features, and inference results. The relationship is simple: streaming provides awareness, time-series data provides history, structured data provides context, and AI transforms that information into intelligence and physical action. 

Streaming Across Cortex-A and Cortex-M 

One of the important opportunities within the S32 family is the ability to build architectures spanning Cortex-A and Cortex-M processing environments. A Cortex-M-based ECU may be responsible for sensing, control, and time-critical processing, while a Cortex-A-based gateway or higher-level controller may perform more advanced analytics, aggregation, visualization, communications, and AI-related functions. 

ITTIA DB technology helps create disciplined data architecture across Cortex-M and Cortex-A environments, transforming real-time sensor streams through local processing and structured data into historical analysis, AI inference, and intelligent decisions. 

This provides an alternative to uncontrolled shared memory or application-specific data movement and creates a clearer path for managing data across heterogeneous S32 architectures. 

Streaming Enables Multimodal Physical AI on S32 

Many automotive and intelligent-machine applications depend on multiple types of information working together. A traction motor health application may combine vibration, temperature, current, RPM, and load; a Battery Management System may combine voltage, current, temperature, charge history, and operating state; a vehicle health application may bring together CAN data, motor data, battery data, thermal data, and diagnostic events; and a zonal or body controller may rely on position, current, switch events, environmental conditions, and fault history.  

Because these data streams often arrive at different rates and from different controllers, they must be organized and correlated before they can become useful for AI. The ITTIA DB Platform helps structure this multimodal information around timestamps, events, ECU states, operating conditions, and historical context, creating a stronger foundation for AI inference, diagnostics, observability, and future model training. 

Streaming Data Can Become AI-Ready Data 

Raw vehicle and sensor data is not always suitable for direct AI inference and often must first be transformed into meaningful features. For example, high-frequency vibration data from a traction motor may be processed into RMS, variance, rolling statistics, rate of change, FFT components, frequency-band energy, and peak characteristics that better represent the motor’s operating condition.  

A streaming engine can perform these transformations continuously as measurements arrive, creating a real-time workflow of Raw S32 Data Stream → Processing Window → Feature Generation → AI-Ready Information → Inference. With the ITTIA DB Platform, streaming and data processing can operate alongside historical data management, allowing the system to preserve original physical-world measurements, derived AI features, operating context, and inference results as part of a unified data foundation for Physical AI. 

Example: Predictive Maintenance on an S32-Based Vehicle 

Consider a traction-motor predictive maintenance application in which motor vibration begins to increase. The ITTIA DB Platform can continuously process the incoming stream, identify abnormal patterns, and generate features such as RMS and FFT components. Historical motor behavior provides the operating context needed to distinguish a temporary variation from a developing fault, while AI can use this combined information to identify possible bearing degradation.  

The vehicle system can then issue a warning, adjust operation, or trigger another response, while the underlying sensor data, AI inference, decision, and resulting action are recorded for traceability and future analysis. This creates a closed-loop Physical AI lifecycle in which the vehicle senses, streams, manages, processes, understands, decides, acts, observes the outcome, and continuously improves.

Example: Streaming for Battery Intelligence 

Battery systems are another important application for Physical AI on NXP S32 platforms. Battery intelligence depends on the continuous analysis of data such as cell voltage, pack current, temperature, charging history, and operating conditions. Streaming enables this information to be processed as it is generated, while historical data provides the context needed to understand degradation, changing performance, and long-term battery behavior.  

The ITTIA DB Platform can help S32-based BMS architectures organize and process this information to support State of Charge (SoC), State of Health (SoH), anomaly detection, thermal analysis, degradation monitoring, and remaining-life estimation. By combining real-time streaming with historical context, the BMS can evolve from simply monitoring present conditions into a more intelligent system capable of understanding trends, identifying emerging issues, and supporting predictive battery decisions. 

The A53 battery inference application makes this pipeline concrete: The following code samples illustrate how ITTIA DB produces feature windows, an application assembles an LSTM input sequence, and the model result returns to an output stream. 

1. Turn incoming measurements into three-second feature windows 

This continuous query groups battery measurements by cell and calculates five features for each window. Equal window and slide intervals create non-overlapping three-second windows.

CSELECT cell_id, 
        SUM(voltage_V * current_A * 1.0) AS energy_delta, 
        AVG(voltage_V) AS avg_voltage, 
        AVG(current_A) AS avg_current, 
        AVG(temperature_C) AS avg_temp, 
        CAST(INTERVAL '3' SECOND AS FLOAT32) AS duration_sec 
  FROM battery_raw_stream 
  FOR SYSTEM_TIME ALL 
  WINDOW INTERVAL '3' SECOND 
  SLIDE INTERVAL '3' SECOND 
  GROUP BY cell_id

2. Preserve the feature sequence and run the LSTM 

The application waits for ten feature rows and arranges them as one sequence of ten steps with five features per step: energy_delta, avg_voltage, avg_current, avg_temp, and duration_sec. The feature sequence is written to feature_windows before preprocessing, inference, postprocessing, and output publication. 

float sData_output; 
while (true) 
{ 
    float32_t sData_input[1][10][5]; 
    wait_10_rows(*input_stream_query, sData_input); 
    ittia_write_feature_window(db_conn, sData_input); 
    single_thread.Preprocess(sData_input); 
    single_thread.Run(); 
    single_thread.Postprocess(&sData_output); 
    ittia_write_output(&sData_output); 
 
    os_sleep(WAIT_MILLISEC(100)); 
}

3. Return the SoH prediction to the streaming data path 

The output function attaches cell ID 1 and the current timestamp to the prediction, then submits it to soh_prediction_stream, making the result available for downstream consumers that make decisions and physical actions.

void ittia_write_output(float* sData_output)
{
    uint32_t cell_id = 1;
    float64_t output = *sData_output;
    os_day_time_t current_time;
    os_day_time(&current_time);
    db_timestamp_usec_t sample_time = current_time;

    db_stream_set_uint32(output_stream_input_node, cellId, cell_id);
    db_stream_set_float32(output_stream_input_node, predictedSoh, output);
    db_stream_set_timestamp_usec(output_stream_input_node, sampleTime, sample_time);
    dbstatus_t Status = db_stream_process(output_stream_input_node);
    if (DB_FAILED(Status))
    {
        std::cout << "Could not write to output stream" << std::endl;
    }
}

Streaming and Software-Defined Vehicles 

As vehicles become increasingly software-defined, ECUs, gateways, and higher-level controllers must manage more data locally and make greater use of it in real time. Streaming information may come from CAN and vehicle networks, battery systems, electric motors, thermal controllers, body and zonal ECUs, diagnostics, sensors and actuators, and AI inference engines.  

An NXP S32 gateway or controller may need to aggregate, process, and correlate these streams while preserving enough historical context to understand system behavior over time. The ITTIA DB Platform provides a structured data foundation for this evolution, helping transform traditional ECU architectures into data-centric Software-Defined Vehicle and Physical AI systems that can continuously observe, understand, decide, and act. 

Streaming and AI Observability 

Physical AI must also explain what happened. An S32-based production system may need to preserve: 

  • The sensor or CAN data that triggered an event 
  • The processing window used 
  • The features generated 
  • The historical operating conditions 
  • The inference result 
  • The decision made 
  • The physical or vehicle action taken 
  • The eventual outcome 

The ITTIA DB Platform can preserve the relationship between these elements, creating a foundation for AI observability, traceability, diagnostics, and explainability. The chain becomes Physical AI connects observation with historical context, transforms data into features and inference, drives decisions and vehicle actions, and records the resulting outcome. 

This becomes increasingly important for automotive systems where reliability, functional safety, diagnostics, and accountability matter. 

Designed for S32 Embedded and Automotive Environments 

S32 devices operate in environments where RAM, flash, CPU resources, communications bandwidth, and timing are constrained. A streaming engine therefore cannot behave like a large cloud streaming platform. It must coexist with control loops, communications, vehicle networking, diagnostics, persistence, and AI inference. 

ITTIA DB technology is designed for embedded architecture spanning MCUs, MPUs, ECUs, gateways, multicore processors, and heterogeneous processing environments. Across the NXP S32 family, this enables developers to build data pipelines in which streaming, persistence, history, data processing, and AI enablement operate close to where vehicle and physical-world data is generated. 

The Data Foundation for S32 Physical AI 

Physical AI on NXP S32 platforms requires more than processors and AI models; it depends on a continuous flow of reliable, contextual, structured, and actionable data. The ITTIA DB Platform creates a continuous data path from the physical world and vehicle sensors through NXP S32 streaming, historical context, and data processing to AI inference, intelligent decisions, physical action, and recorded outcomes. 

Streaming gives the S32 system real-time awareness, historical data provides memory, data processing creates understanding, and AI delivers inference. Together, these capabilities provide the data foundation for S32-based systems that can continuously sense, understand, decide, act, observe, and improve. Physical AI on NXP S32 needs real-time intelligence, and real-time intelligence begins with trusted streaming data. 

Discover the Possibilities with ITTIA for NXP S32 

Are you developing an NXP S32-based ECU, gateway, domain controller, or intelligent automotive system that requires reliable data management, real-time streaming, historical context, data processing, or AI enablement?  

We invite you to connect with ITTIA experts to explore how the ITTIA DB Platform can help transform S32 applications into more intelligent, data-centric systems for Software-Defined Vehicles and Physical AI. 

Our team can review your S32 architecture, Cortex-A and Cortex-M environment, vehicle and sensor data sources, streaming requirements, storage constraints, processing workloads, and AI integration plans.  

We can then demonstrate how the ITTIA DB Platform can help organize real-time and historical data, prepare AI-ready information, preserve inference and decision context, and support reliable intelligent action across applications such as vehicle health, predictive maintenance, battery management, zonal systems, gateways, and advanced automotive intelligence.

Request Demonstration