SRMtech · Desktop Application
ST_ERA Signal Analysis Tool
High-performance oscilloscope signal analysis for automotive and electronic software development
ST_ERA is a high-performance desktop application built to simplify oscilloscope signal analysis in automotive and electronic software development. In complex engineering workflows, validating ECU or sensor responses requires comparing high-frequency signals against baseline specifications — an effort that is difficult to perform manually with accuracy at scale.
ST_ERA addresses this by offering an interactive visual environment that automatically aligns signals, detects fine-grained deviations, and delivers instant OK / NG validation. Designed for electrical engineers, ECU developers, and signal analysts, it enables rapid verification of parameters, identification of extreme variations, and reliable validation across test iterations.
The application runs on Windows with a Python-powered backend capable of processing large datasets. It requires minimal setup and provides a comprehensive dashboard with synchronized signal tracking and detailed deviation insights, supporting efficient review and collaboration.
Core capabilities
Signal alignment
Automatically aligns signals from Base and Target datasets for accurate side-by-side comparison.
Deviation detection
Detects fine-grained deviations and marks extreme variation points with precision markers.
OK / NG validation
Delivers instant colour-coded pass/fail results for each signal under test.
Synchronized tracking
Trackball movement on one panel mirrors across all active charts for precise temporal correlation.
Dual-view inspection
Inline zoom creates a micro-macro view — full signal trend and time-slice zoom simultaneously.
High-speed processing
Data chunking logic keeps the UI responsive even when handling millions of high-frequency data points.
Supported input formats
.dat
.mdf
.pkl
Technology stack
Flutter (Windows desktop)
Python 3.9+
VS Code
SyncFusion charts
Pickle / Parquet
Runs on Windows. The application requires Flutter SDK, Python 3.9+, and VS Code with the Dart and Python extensions. No external server or cloud connection is needed during operation.
1
Repository & Environment Setup
Clone the repo, install dependencies, and configure your IDE
Before you begin: Confirm Flutter SDK and Python 3.9+ are installed on your Windows machine. Contact your team lead for the repository URL and your assigned branch name.
- 1Clone the ST_ERA repository and switch to your designated branch.
- 2Verify Flutter SDK is installed by running
flutter doctorin a terminal. All checks should pass. - 3Verify Python 3.9+ is installed by running
python --version. - 4Open the project in VS Code and install the Dart and Python extensions from the Extensions marketplace.
- 5Install Python backend dependencies by navigating to the backend folder and running
pip install -r requirements.txt.
Flutter and Python must both be on your PATH. If
flutter doctor or python --version fails, resolve the environment variables before proceeding.2
Concurrent System Launch
Start the backend engine and the Flutter UI in separate terminals
Two terminals required. The backend and frontend must run simultaneously. Do not close either terminal while using the application.
- 1Open the first terminal (PowerShell), navigate to the backend folder, and start the Data Processing Engine.
- 2Open a second terminal, navigate to the project root, and launch the Flutter Signal Visualization Hub on Windows.
- 3Wait for both processes to report they are running before interacting with the UI.
# Terminal 1 — Start the Data Processing Engine
cd d:\DP\ST_ERA\backend
python app.py
# Terminal 2 — Launch the Signal Visualization Hub
cd d:\DP\ST_ERA
flutter run -d windows
Both processes must stay running. The Flutter UI communicates with the Python backend in real time. If the backend is stopped, signal processing will fail.
3
High-Performance Data Pipeline
Upload .dat files and let the system convert them for fast processing
Upload your target .dat files (MDF format). The tool converts them automatically into
.pkl (Pickle) or .parquet formats, enabling near-instant loading of millions of data points on subsequent runs.- 1In the ST_ERA UI, click the Upload button and select your target
.datfile(s) in MDF format. - 2The backend will process the file and convert it to
.pklor.parquetformat automatically. - 3Wait for the conversion to complete. A progress indicator will be visible in the UI. Large files may take a moment on first load.
- 4Once converted, subsequent loads of the same file will be near-instant due to the optimised format.
Supported formats
.dat (MDF)
.pkl (output)
.parquet (output)
4
Centralised Variable Management
Find and select the signal tags you need from the Variable Discovery List
The Variable Discovery List is the central hub for navigating your data. It surfaces all available signal streams from the uploaded file so you can select exactly what to analyse.
- 1Open the Variable Discovery List panel in the sidebar of the UI.
- 2Use the search bar to filter through thousands of signal tags by name or keyword.
- 3Identify the data streams you need for your analysis and note or select them for plotting in the next step.
Tip: Search using partial signal names or known prefixes (e.g.,
ECU_, CAN_) to quickly narrow down relevant variables in large datasets.5
Visual Workspace Architecture
Build your analysis layout by dragging variables into Graph Panels
- 1From the Variable Discovery List, drag a signal variable into the main workspace area to create a new Graph Panel.
- 2Add additional variables to create multiple independent Graph Panels side by side.
- 3Each panel manages its own rendering state — zoom level, visible range, and Y-axis bounds are panel-specific.
- 4All panels remain part of the global synchronisation context, so trackball and time-axis navigation stays aligned across panels (see Step 9).
Design your workspace intentionally. Group related signals in adjacent panels to make cross-signal comparison easier during the deviation analysis in Step 10.
6
Optimised Logic for Large Datasets
Understand how the data chunking system keeps the UI responsive
No action needed — this works automatically. The data chunking logic runs in the background. This step explains what is happening so you understand the behaviour when working with large files.
Data chunking
Segmented data loading
Instead of loading the entire dataset into memory at once, the backend loads data in chunks based on the current visible time range. This keeps memory usage efficient and rendering fast.
Rendering engine
SyncFusion series rendering
The UI uses optimised SyncFusion chart series that can render thousands of data points without frame drops, even during interactive pan and zoom operations.
If the UI feels slow, check that the Python backend is still running in its terminal. A stopped backend causes rendering to stall as the UI waits for data chunks.
7
Auto-Adaptive Y-Axis Scaling
Dynamic auto-scaling keeps every signal perfectly centred during navigation
Automatic — no manual configuration needed. The Y-axis adjusts its bounds in real-time as you pan or zoom along the time axis.
- 1As you pan left or right along the time axis, the Y-axis automatically recalculates its upper and lower bounds based on the currently visible data range.
- 2The signal remains perfectly centred and legible at all zoom levels without requiring manual axis adjustments.
- 3This is especially valuable when inspecting high-frequency signals with large amplitude variations across different time windows.
Why this matters: Without auto-scaling, small deviations in a high-amplitude signal can appear invisible if the Y-axis is fixed to the full data range. Dynamic scaling ensures deviations are always clearly visible.
8
Dual-View Inspection Framework
Use the Inline Zoom Toggle for simultaneous macro and micro views
The Inline Zoom Toggle creates a secondary high-fidelity panel directly beneath any graph, enabling a "micro-macro" view of your signal.
Macro view
Full signal trend
The upper panel shows the complete signal across the full time range, giving you the overall shape and any global anomalies.
Micro view
High-fidelity time-slice
The lower panel zooms into the selected time-slice at high fidelity, showing fine-grained waveform detail that is invisible at macro scale.
- 1Click the Inline Zoom Toggle on any Graph Panel to enable the dual view.
- 2Use the selection handle in the macro view to choose the time-slice you want to inspect in detail.
- 3The micro view below updates in real time as you move the selection window.
9
Correlated Signal Tracking
Synchronised trackball navigation across all active panels
The Synchronised Trackball System mirrors your cursor position and time marker across all active Graph Panels simultaneously, establishing precise temporal correlation between different signals.
- 1Move your cursor over any active Graph Panel. The trackball cursor will appear on all panels at the corresponding time position.
- 2Read the exact signal values at that time point from the tooltip on each panel simultaneously.
- 3Use this to verify that multiple signals — for example ECU output and sensor response — are in the correct temporal relationship to each other.
Best practice: Arrange panels for signals you expect to be causally related (e.g., trigger signal and response signal) side by side to make temporal offsets visually obvious during trackball inspection.
10
Real-Time Deviation Analytics
Apply comparison logic and interpret OK / NG validation results
This is the final validation step. Apply the Comparison Logic to calculate variance between signals and receive instant colour-coded results.
- 1With your signals plotted, activate the Comparison Logic from the toolbar or comparison panel.
- 2The system calculates variance between the reference and target signals instantly across the full dataset.
- 3Review the colour-coded results — each signal section is marked OK (within tolerance) or NG (deviation exceeded).
- 4Extreme deviation points are marked with precision markers on the graph for immediate identification.
- 5Document or export the results for review and sign-off.
Validation result codes
OK — Signal within tolerance. No action required.
NG — Deviation exceeded threshold. Investigation required.
NG results must be investigated. An NG outcome indicates the signal deviated beyond the acceptable threshold. Log the time-stamp, magnitude, and affected signal name before closing the session.
?
Troubleshooting
Common issues and how to resolve them
flutter doctor reports errors during setup ▼
Run
flutter doctor --verbose to see the detailed diagnosis. Commonly missing items are Visual Studio build tools or Android Studio setup. For Windows desktop targets, ensure "Desktop development with C++" workload is installed via Visual Studio Installer.Backend (python app.py) fails to start ▼
Check that your virtual environment is active if you used one, and that all packages from
requirements.txt installed successfully. Common culprits are missing numpy, pandas, or mdflib packages. Run pip install -r requirements.txt again and check for error messages.Flutter UI shows blank or fails to connect to backend ▼
Confirm the Python backend is running in its terminal and has reported it is ready to accept connections. Check that the backend port (default:
5000 or as configured) is not blocked by a Windows Firewall rule. Restart both processes if needed..dat file upload fails or hangs ▼
Verify the file is a valid MDF-format
.dat file. Check that the backend terminal is still running — a stopped backend causes uploads to hang silently. For very large files, allow more time; the first conversion to .pkl can take several minutes.Variable Discovery List is empty after file upload ▼
This usually indicates the file conversion did not complete successfully. Check the backend terminal for error messages during the upload. Ensure the file format is MDF-compatible. Try re-uploading the file after restarting both the backend and the UI.
UI becomes slow or unresponsive during pan/zoom ▼
This can occur if the backend data chunking is overwhelmed by very high-frequency signals. Reduce the number of active Graph Panels to the minimum needed, or reduce the visible time window. Ensure no other CPU-intensive processes are running alongside the application.
Comparison results all show NG unexpectedly ▼
Verify that the correct reference and target signals are assigned to the comparison. Check the tolerance threshold settings — they may be set too tightly for the signal type. If signals have a known time offset, ensure they are aligned before applying comparison logic.
Synchronised trackball is not aligned across panels ▼
This can happen if panels have different time-base offsets (e.g., files from different recording sessions). Ensure all plotted signals come from the same uploaded dataset. If signals are from different files, time-alignment must be performed before synchronisation will work correctly.