Resonance

Offline, physics-first vibration intelligence system for SME industrial machinery. Detects bearing wear, misalignment, cavitation, and imbalance before catastrophic failure.

Built on AMD Ryzen AI edge hardware. Zero cloud dependency. Alerts in Hindi, Marathi, English.

System Architecture

Host Machine
└── Node A (C++ DSP)
      Subscribes: USB Audio (44.1kHz)
      Publishes:  ZMQ tcp://*:5555  [1024×64 spectrogram tensor]

Docker Network
├── Node B (Python Inference)
│     Subscribes: ZMQ :5555
│     Publishes:  ZMQ :5557  {mse, rms, severity, alert}
│     Runtime:    ONNX Runtime (CPU dev) · Vitis AI (NPU target)
│
├── Web (Node.js + React Dashboard)
│     Subscribes: ZMQ :5557
│     Serves:     http://localhost:3001
│
└── LLM (Llama 3.1 8B — Optional)
      Serves: :11434 via Ollama (local only, no cloud API)

Repository Structure

Resonance/
├── src/                          # Node A — C++ DSP Engine
│     ├── main.cpp
│     ├── ear.cpp                 # PortAudio input capture
│     ├── fft.cpp                 # FFTW3 FFT processing
│     ├── filters.cpp             # High-pass / low-pass filters
│     ├── spectrogram.cpp         # Log-magnitude spectrogram
│     ├── broadcaster.cpp         # ZMQ PUB :5555
│     └── safety.cpp              # RMS safety gate
│
├── include/resonance/            # C++ header files
│     ├── ear.hpp
│     ├── fft.hpp
│     ├── filters.hpp
│     ├── spectrogram.hpp
│     ├── broadcaster.hpp
│     └── safety.hpp
│
├── python/
│     ├── inference/
│     │     └── main.py           # Node B — ONNX inference + LLM alerts
│     ├── llm/
│     │     └── handler.py        # LLMProvider → LocalLLM → LLMHandler
│     ├── training/
│     │     ├── collect_data.py   # Healthy baseline collection
│     │     ├── dataset.py        # Spectrogram dataset loader
│     │     ├── model.py          # ConvAutoencoder architecture
│     │     ├── train.py          # Training loop
│     │     └── export_onnx.py    # PyTorch → ONNX export
│     ├── onnx/
│     │     ├── autoencoder.onnx  # Deployed model
│     │     └── model_hash.txt    # SHA-256 integrity hash
│     ├── weights/
│     │     ├── autoencoder.pth   # PyTorch checkpoint
│     │     └── norm_stats.json   # Normalization parameters
│     ├── utils/
│     │     ├── config.py         # Thresholds, ZMQ endpoints, LLM config
│     │     ├── zmq_receiver.py   # ZMQ subscriber
│     │     ├── rms_monitor.py    # Standalone RMS visualizer
│     │     └── dsp.py            # DSP utilities
│     ├── tests/
│     │     ├── mock_node_a.py    # ZMQ mock publisher for testing
│     │     ├── evaluate_model.py # MSE threshold evaluation
│     │     └── verify_e2e.py     # End-to-end pipeline verifier
│     ├── run_inference.py        # Entry point
│     ├── requirements.txt
│     ├── Dockerfile
│     └── README.md
│
├── web/                          # Node C — React Dashboard
│     ├── app/                    # React components + hooks
│     ├── styles/                 # CSS + Tailwind
│     ├── server.js               # Node.js relay (ZMQ → Socket.IO)
│     ├── index.html
│     ├── package.json
│     ├── vite.config.ts
│     └── Dockerfile
│
├── schema/                       # Data schemas
├── docker-compose.yml
├── runall.sh                     # Start all services locally
├── CMakeLists.txt
└── README.md

Hardware Requirements

Target Deployment

Tier 1 — Raspberry Pi Zero 2W · USB Audio Adapter (C-Media CM108 compatible) · Piezo disc 35mm
Tier 2 — AMD Ryzen AI Mini PC · XDNA NPU · 50 TOPS · Vitis AI Runtime
Tier 3 — Ryzen 5 Edge Mini PC · Node.js dashboard · PostgreSQL archive

Development Mode

Any Linux machine with Docker installed
USB audio adapter or built-in microphone
Node A validated on x86 — Pi Zero 2W deployment target

Sensor BOM (Tier 1)

Component	Spec	Cost
Raspberry Pi Zero 2W	Quad-core ARM 1GHz 512MB	₹1,299
USB Audio Adapter	C-Media CM108 44.1kHz	₹299
Piezo Disc 35mm	PZT ceramic contact	₹80
1.2MΩ Bias Resistor	1/4W carbon film	₹2
1µF Capacitor	25V electrolytic DC block	₹8
2N3819 JFET Buffer	N-ch TO-92 impedance match	₹20
Total BOM		₹2,491

Run Without Docker

Step 1 — Build Node A (C++ DSP)

git clone https://github.com/HSKCTA/Resonance.git
cd Resonance
mkdir build && cd build
cmake ..
make
./resonance_node_a

Node A begins publishing spectrograms on ZMQ tcp://*:5555.

Step 2 — Run Node B (Inference)

cd python
pip install -r requirements.txt
python run_inference.py

Node B subscribes to :5555 and publishes results on :5557.

Step 3 — Run Dashboard

cd web
npm install
npm run dev

Dashboard available at http://localhost:5173

Or use the launcher script

./runall.sh        # starts all 5 services
./runall.sh stop   # stops everything

Run With Docker (Recommended)

Step 1 — Start Node A on host

Node A must run on host to access USB audio hardware:

cd build
./resonance_node_a

Step 2 — Start all containers

docker compose up --build

This starts Node B (inference), Web (dashboard), and the Ollama LLM container.

Step 3 — Open dashboard

http://localhost:3001

LLM Alerts (Optional)

Pull Llama 3.1 8B for local multilingual fault explanations:

docker exec -it resonance_ollama ollama pull llama3.1:8b

If not pulled, system runs with fallback rule-based alert text. LLM delivers fault explanations in English, Hindi, and Marathi.

Signal Pipeline

Piezo Sensor
     │
     ▼
PortAudio (44.1kHz capture)
     │
     ▼
High-Pass Filter (100Hz) + Low-Pass Filter (12kHz)
     │
     ├── RMS Amplitude → Safety Gate (ISO 10816 threshold)
     │         └── HARDWARE ALARM if RMS > threshold (bypasses AI)
     │
     ▼
FFTW3 (2048-pt FFT · 75% overlap)
     │
     ▼
Log-Magnitude Spectrogram [1024 × 64]
     │
     ▼
ZMQ PUB :5555
     │
     ▼
ConvAutoencoder (ONNX Runtime · CPU / AMD Ryzen AI NPU)
     │
     ▼
MSE Reconstruction Error
     │
     ├── MSE > 0.180 → ANOMALY DETECTED
     │         └── Llama 3.1 8B LLM → alert in Hindi / Marathi / English
     │
     └── MSE ≤ 0.180 → NORMAL

Fault Detection Science

Industrial faults produce specific spectral signatures detectable weeks before failure:

Fault Type	Spectral Signature	Detection Method
Bearing Wear	High-frequency harmonics >5kHz	Autoencoder MSE
Misalignment	Strong 2× 3× shaft frequency peaks	FFT harmonic analysis
Looseness	Frequency sidebands	Spectral analysis
Imbalance	Large 1× shaft frequency peak	RMS safety gate

Standards compliance: ISO 10816-3:2009 · ISO 13373-1:2002

Model Card

Property	Value
Architecture	Convolutional Autoencoder
Input	1024×64 log-magnitude spectrogram
Training data	Healthy vibration only (unsupervised)
Loss function	Mean Squared Error (MSE)
Anomaly threshold	0.180 (calibrated on healthy baseline data)
Export format	ONNX FP32
Runtime	ONNX Runtime (CPU) · Vitis AI (NPU target)
Inference latency	3ms median CPU · ~1.4ms projected AMD NPU
Parameters	~180K

Normalization

Min-max normalization applied before inference. Parameters stored in python/weights/norm_stats.json. Must be regenerated if sensor hardware changes — run collect_data.py then train.py.

Limitations

Trained on small healthy dataset — retrain on target machine for best results
Single fault type detection — fault classifier roadmap Q2 2026
Threshold calibrated manually — adaptive threshold planned

Evaluation

cd python
python tests/evaluate_model.py

Reports MSE distribution on training data and recommended threshold.

Spectrogram Parameters

Parameter	Value
Sample rate	44,100 Hz
FFT size	2048 points
Overlap	75%
Frequency bins	1024
Time steps	64
Output shape	[1, 1024, 64]

Benchmarks

A. Inference Latency (Validated)

Model: ConvAutoencoder FP32 ONNX · Input: 1024×64 · Runs: 1000 · Warmup: 50

Metric	CPU (x86 dev)	NPU Projection*
Mean	7.0 ms	~1.4 ms
Median (P50)	3.0 ms	~0.6 ms
P95	21.7 ms	~4.3 ms
P99	27.7 ms	~5.5 ms
Min	1.3 ms	—
Max	34.7 ms	—

*NPU projection: AMD Ryzen AI XDNA 50 TOPS · ~5× CPU speedup for FP32 ONNX via Vitis AI Runtime · Ryzen AI 9 HX 370 · validated benchmarks pending target hardware.

B. DSP Pipeline Latency (Validated)

Stage	Latency
FFT (64 hops · 2048-pt)	1.5 ms
Spectrogram build	0.09 ms
Audio buffer fill*	~743 ms

*Audio buffer fill requires 64 frames at 44.1kHz to construct one spectrogram. This is a physics constraint identical across all vibration monitoring systems.

C. End-to-End Pipeline (Validated)

Tested: mock_node_a → ZMQ :5555 → Node B (ONNX) → ZMQ :5557 → verifier

Metric	Result
Frames tested	10/10 successful
Pipeline mean (ZMQ + inference)	30.9 ms
Pipeline worst case	51.0 ms
Audio buffer fill	~743 ms (physics)
Full sensor-to-alert	~774 ms mean
MSE on healthy data	~0.003 (consistent)
ZMQ transport	✓ verified
LLM fallback	✓ graceful — no crash on unavailable model

Pipeline target: <100ms inference ✓ (30.9ms measured)

Test Environment

CPU: AMD Ryzen 5 (Yoga 6 13ARE05)
OS: Linux
Runtime: ONNX Runtime · CPUExecutionProvider
DSP: C++17 · FFTW3 · PortAudio
Inference runs: 1000 · Warmup: 50

Privacy and Deployment

No audio data leaves the local network
Human voice range (80Hz–3kHz) filtered before AI layer — conversations never processed
No cloud dependency for core inference
Air-gapped factory deployment supported
LLM runs locally via Ollama — no external API calls in production
Read-only system — never sends control commands to machinery

Cost

Tier	Hardware	BOM Cost	Deploy Price
Tier 1 — Sensor Node	Pi Zero 2W + Piezo	₹2,491	₹3,499
Tier 2 — NPU Zone	AMD Ryzen AI Mini PC	₹81,296	₹89,999
Tier 3 — Master Node	Ryzen 5 Edge Mini PC	₹64,996	₹72,999
20-machine SME	2 zones + 1 master	—	₹3,47,977

SKF equivalent: ₹9,00,000 hardware + ₹2,00,000/yr cloud. Resonance: 85% cheaper. Zero cloud cost.

Roadmap

Phase	Timeline	Feature
Q1 2026	Now	ConvAutoencoder · batched NPU inference · 50 sensors/zone
Q2 2026	3 months	Fault type classifier — bearing vs imbalance vs looseness
Q3 2026	6 months	Remaining useful life estimator — LSTM on MSE trend
Q4 2026	12 months	Multi-factory dashboard · SCADA integration · AMD EPYC

Team

Hitesh Khare — Systems Engineering · C++ DSP Core Tanmay Bhole — AI/ML Architecture · Model Training · GenAI

AMD Slingshot 2026 · Team DataNOtfOund

Name		Name	Last commit message	Last commit date
Latest commit History 52 Commits
.github		.github
data		data
deploy		deploy
docs		docs
include/resonance		include/resonance
python		python
schema		schema
src		src
web		web
.gitignore		.gitignore
CMakeLists.txt		CMakeLists.txt
README.md		README.md
benchmark_dsp		benchmark_dsp
benchmark_dsp.cpp		benchmark_dsp.cpp
docker-compose.yml		docker-compose.yml
requirements.txt		requirements.txt
runall.sh		runall.sh

Folders and files

Latest commit

History

Repository files navigation

Resonance

System Architecture

Repository Structure

Hardware Requirements

Target Deployment

Development Mode

Sensor BOM (Tier 1)

Run Without Docker

Step 1 — Build Node A (C++ DSP)

Step 2 — Run Node B (Inference)

Step 3 — Run Dashboard

Or use the launcher script

Run With Docker (Recommended)

Step 1 — Start Node A on host

Step 2 — Start all containers

Step 3 — Open dashboard

LLM Alerts (Optional)

Signal Pipeline

Fault Detection Science

Model Card

Normalization

Limitations

Evaluation

Spectrogram Parameters

Benchmarks

A. Inference Latency (Validated)

B. DSP Pipeline Latency (Validated)

C. End-to-End Pipeline (Validated)

Test Environment

Privacy and Deployment

Cost

Roadmap

Team

About

Topics

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages