Published September 13, 2026 © GPL3+

Real-Time Motor Vibration Anomaly Detection Using Edge AI

Detect abnormal motor vibrations in real time by running a NanoEdge AI Machine Learning model directly on an STM32 microcontroller.

AdvancedFull instructions provided2 hours61

Real-Time Motor Vibration Anomaly Detection Using Edge AI

Things used in this project

Hardware components

STM32F103C8T6

Adafruit Analog Accelerometer: ADXL335

SparkFun Electronics SparkFun USB to Serial Breakout - FT232RL

5 mm LED: Red

5 mm LED: Green

Resistor 220 ohm

Male/Female Jumper Wires

Male/Male Jumper Wires

ST Link V2 Programmer For STM8 and STM32

Nano USB A-Mini B 1.2m Cable Nickel-Plated Connector

DC Cooling Blade Fan

Software apps and online services

Arduino IDE

Nano Edge AI Studio

Hand tools and fabrication machines

Digilent Mastech MS8217 Autorange Digital Multimeter

Wire Stripper & Cutter, 18-10 AWG / 0.75-4mm² Capacity Wires

Story

Project Overview

This project demonstrates a real-time motor vibration anomaly detection system using an STM32 microcontroller, GY-61 3-axis accelerometer, Arduino IDE, and NanoEdge AI. The system captures vibration signals from a rotating motor, collects normal and abnormal operating data, and uses NanoEdge AI Studio to benchmark and select a suitable Machine Learning library.

After the ML library is generated, it is integrated into the Arduino IDE project and deployed to the STM32. The final system performs ML inference directly on the STM32 MCU, allowing the motor's vibration pattern to be analyzed locally without requiring a PC or cloud-based ML service during operation.

The project demonstrates a practical Edge AI / TinyML approach for real-time machine condition monitoring and anomaly detection.

What You Will Learn

By completing this project, you will learn how to:

Capture vibration data from a GY-61 accelerometer.
Sample 3-axis vibration data using the STM32 ADC.
Collect normal and abnormal motor vibration signals.
Use a buffered data logger for high-speed signal acquisition.
Benchmark anomaly-detection libraries using NanoEdge AI Studio.
Generate and download a NanoEdge AI ML library.
Integrate .h and .a library files into an Arduino project.
Deploy the ML library on an STM32 MCU.
Perform real-time ML inference directly on the microcontroller.
Classify motor behavior as NORMAL or ANOMALY.

1. Introduction

Briefly explain the problem of monitoring motor vibration and the goal of the project.

2. System Overview

Explain:

Motor → GY-61 → STM32 → NanoEdge AI → NORMAL/ANOMALY

3. Hardware Connections

4. Capture Normal and Abnormal Vibration Data

Introduce:

Buffer_DataLogger_128.ino

Explain the 256 × 3-axis buffer and approximately 1000 Hz sampling.

5. Normal Vibration Data

Run the motor normally and capture multiple signal windows.

6. Abnormal Vibration Data

Introduce the selected abnormal/disturbed condition and capture another set of vibration signals.

7. NanoEdge AI Studio Benchmarking

Import the normal and abnormal datasets and benchmark the available anomaly-detection libraries.

8. Generate the NanoEdge AI Library

After benchmarking, the selected NanoEdge AI library is generated and downloaded.

The generated library contains the components required to run the anomaly-detection algorithm on the target STM32 MCU.

For the Arduino IDE project, the important files include:

NanoEdgeAI.h
libneai.a
library.properties

The library must be placed in the correct Arduino library structure.

9. Install NanoEdge AI Library in Arduino IDE

The library folder should follow the required structure:

The NanoEdge AI header file: "NanoEdgeAI.h" provides the declarations required by the Arduino program.

The compiled ML library: "libneai.a" contains the implementation that is linked into the STM32 firmware.

Important:

The.h file and.a file should not simply be placed anywhere in the Arduino project.

They need to be placed according to the required Arduino library structure so that the compiler can correctly find and link the NanoEdge AI library.

10. Deploy the ML Model on STM32

After installing the NanoEdge AI library, the final anomaly-detection program (Motor_Anomaly.ino ) is opened in the Arduino IDE. The program includes: #include "NanoEdgeAI.h" The firmware is then compiled and uploaded to the STM32F103C8T6.

The most important feature of this project is that the Machine Learning model runs directly on the STM32 microcontroller. This makes the system an Edge AI application, because the anomaly detection and ML inference are performed locally on the MCU rather than on a PC or cloud server. After the NanoEdge AI library is generated, it becomes part of the STM32 firmware and is executed directly by the microcontroller. During operation, the STM32 continuously collects vibration data from the GY-61 accelerometer and passes the signal to the NanoEdge AI library. The ML model analyzes the vibration pattern and generates a similarity value, which indicates how closely the current signal matches the learned normal behavior. The program then compares this similarity value with a predefined threshold to determine whether the machine is operating in a NORMAL or ANOMALY condition.

Applications

Motor condition monitoring
Predictive maintenance
Bearing monitoring
Industrial equipment monitoring
Vibration monitoring
Edge AI
TinyML

Code

// ============================================================
// STM32F103C8T6 + GY-61
// Non-Blocking High-Speed Data Logger (True 1000 Hz)
// ============================================================

#define ACC_X PA0
#define ACC_Y PA1
#define ACC_Z PA2

HardwareSerial MySerial(PA10, PA9);

const uint16_t BUFFER_SIZE = 256;
const uint32_t SAMPLE_PERIOD_US = 1000; // 1 ms = 1000 Hz

// Storage arrays in RAM (takes only ~1.5 KB of STM32's 20 KB RAM)
uint16_t x_buf[BUFFER_SIZE];
uint16_t y_buf[BUFFER_SIZE];
uint16_t z_buf[BUFFER_SIZE];

void setup()
{
  analogReadResolution(12);
  MySerial.begin(115200);
  delay(1000);
}

void loop()
{
  uint32_t nextSampleTime = micros();

  // ------------------------------------------------
  // 1. FAST SAMPLING PHASE (Strict 1000 Hz, No Serial)
  // ------------------------------------------------
  for (uint16_t sample = 0; sample < BUFFER_SIZE; sample++)
  {
    while ((int32_t)(micros() - nextSampleTime) < 0)
    {
      // Wait for exact microsecond mark
    }
    nextSampleTime += SAMPLE_PERIOD_US;

    // Read ADC and store immediately in RAM (~40 us total)
    x_buf[sample] = analogRead(ACC_X);
    y_buf[sample] = analogRead(ACC_Y);
    z_buf[sample] = analogRead(ACC_Z);
  }

  // ------------------------------------------------
  // 2. DUMP PHASE (Transmit safely after collection)
  // ------------------------------------------------
  for (uint16_t sample = 0; sample < BUFFER_SIZE; sample++)
  {
    MySerial.print(x_buf[sample]);
    MySerial.print(" ");
    MySerial.print(y_buf[sample]);
    MySerial.print(" ");
    MySerial.print(z_buf[sample]);

    if (sample < BUFFER_SIZE - 1)
    {
      MySerial.print(" ");
    }
  }
  MySerial.println(); // Signal end of buffer to NanoEdge AI

  // Brief pause before capturing next signal window
  delay(50);
}

#include "NanoEdgeAI.h"

// ---------------- SENSOR PINS ----------------
#define ACC_X PA0
#define ACC_Y PA1
#define ACC_Z PA2

// ---------------- STATUS LED PINS ----------------
#define LED_PC13 PC13  // Onboard Blue Pill LED (Active-LOW)
#define LED_PA5  PA5   // Normal indicator LED (Active-HIGH)
#define LED_PA6  PA6   // Anomaly indicator LED (Active-HIGH)

// UART debug on PA9/PA10
HardwareSerial MySerial(PA10, PA9);

// Buffer size: 256 * 3 = 768 floats[cite: 1]
float input_signal[NEAI_INPUT_SIGNAL_LENGTH * NEAI_INPUT_AXIS_NUMBER];
uint8_t similarity = 0;

void setup() {
  // Configure LED pins as outputs
  pinMode(LED_PC13, OUTPUT);
  pinMode(LED_PA5, OUTPUT);
  pinMode(LED_PA6, OUTPUT);

  // Default state: all LEDs OFF at start
  digitalWrite(LED_PC13, HIGH); // PC13 is active-low (HIGH = OFF)
  digitalWrite(LED_PA5, LOW);   // PA5 OFF
  digitalWrite(LED_PA6, LOW);   // PA6 OFF

  // 12-bit ADC configuration
  analogReadResolution(12);

  MySerial.begin(115200);
  delay(1000);

  // Initialize NEAI with pretrained model[cite: 1]
  bool use_pretrained = true;
  enum neai_state state = neai_anomalydetection_init(use_pretrained);
  
  if (state != NEAI_OK) {
    MySerial.print("Init Error: ");
    MySerial.println(state);
    while (1); // Halt
  }
  MySerial.println("NEAI Model Ready.");
}

void loop() {
  uint32_t nextSampleTime = micros();

  // 1000 Hz hardware-aligned capture
  for (uint16_t sample = 0; sample < NEAI_INPUT_SIGNAL_LENGTH; sample++) {
    while ((int32_t)(micros() - nextSampleTime) < 0);
    nextSampleTime += 1000;

    uint16_t idx = sample * NEAI_INPUT_AXIS_NUMBER;
    input_signal[idx]     = (float)analogRead(ACC_X);
    input_signal[idx + 1] = (float)analogRead(ACC_Y);
    input_signal[idx + 2] = (float)analogRead(ACC_Z);
  }

  // Run Inference[cite: 1]
  enum neai_state state = neai_anomalydetection_detect(input_signal, &similarity);

  if (state == NEAI_OK) {
    MySerial.print("Similarity: ");
    MySerial.print(similarity);

    if (similarity < 85) {
      // ---------------- ANOMALY DETECTED ----------------
      MySerial.println("% -> [ANOMALY]");

      // Turn OFF normal LEDs
      digitalWrite(LED_PC13, HIGH); // PC13 OFF (active-low)
      digitalWrite(LED_PA5, LOW);   // PA5 OFF

      // Turn ON anomaly LED
      digitalWrite(LED_PA6, HIGH);  // PA6 ON
    } else {
      // ---------------- NORMAL OPERATION ----------------
      MySerial.println("% -> [NORMAL]");

      // Turn ON normal LEDs
      digitalWrite(LED_PC13, LOW);  // PC13 ON (active-low)
      digitalWrite(LED_PA5, HIGH);  // PA5 ON

      // Turn OFF anomaly LED
      digitalWrite(LED_PA6, LOW);   // PA6 OFF
    }
  }
}