Edge Device Sentinels Using Modbus Heat-Map Alarms For Cnc Spindle Microstalls

I got curious about a super specific failure mode in smart manufacturing: microstalls on a CNC spindle—those tiny hesitations that don’t trip the obvious “machine fault” alarms, but they absolutely ruin surface finish over time. I wanted something lightweight that could run at the machine edge and catch the pattern early.

So I built a tiny “edge sentinel” that watches Modbus registers (typical industrial telemetry) and turns the last few minutes of spindle current + speed into a simple heat-map alarm. When the pattern looks wrong, it triggers an alert immediately—no waiting for a cloud dashboard.

What I built (in plain terms)

• Modbus: a common industrial protocol where a controller exposes values as numbered registers (think “address 40001 = spindle speed”).
• I poll two values:
  • Spindle speed (RPM)
  • Spindle current (amps) — a proxy for load
• I keep a short sliding window (last N samples).
• I compute a “heat” score: when speed drops while current stays high (or spikes), that often indicates a microstall (the motor is working hard but not turning smoothly).
• If the score crosses a threshold, the sentinel prints an alert (and would be the place to trigger a relay, MQTT message, or whatever your factory uses).

The logic (simple and testable)

For each sample:

• speed_ratio = speed / nominal_speed
• current_ratio = current / nominal_current
• Heat increases when:
  • speed is low, but
  • current is high (load without motion)

The heat score for a sample:

• heat = (1 - speed_ratio) * current_ratio

Then I average heat over the window. If avg_heat is above a threshold, we trigger.

Step-by-step code: edge sentinel in Python

This script is self-contained and includes a simulator so you can run it without real hardware. Later, swapping the simulator with a real Modbus client is straightforward (the alarm logic stays the same).

import random
import time
from collections import deque

class ModbusSentinel:
    def __init__(
        self,
        nominal_speed_rpm=6000,
        nominal_current_a=5.0,
        window_size=30,
        heat_threshold=0.35,
    ):
        """
        nominal_speed_rpm: expected 'healthy' spindle speed
        nominal_current_a: expected 'healthy' spindle current
        window_size: how many samples to average over (poll interval matters)
        heat_threshold: above this, we declare a microstall risk
        """
        self.nominal_speed_rpm = nominal_speed_rpm
        self.nominal_current_a = nominal_current_a
        self.window_size = window_size
        self.heat_threshold = heat_threshold

        self.heat_window = deque(maxlen=window_size)

    def add_sample(self, speed_rpm, current_a):
        # Convert to ratios so the logic doesn't care about absolute units too much
        speed_ratio = max(speed_rpm / self.nominal_speed_rpm, 0.0)
        current_ratio = max(current_a / self.nominal_current_a, 0.0)

        # Heat increases when speed is low but current is high
        heat = (1.0 - speed_ratio) * current_ratio

        self.heat_window.append(heat)

        avg_heat = sum(self.heat_window) / len(self.heat_window)
        return avg_heat

    def check_alarm(self, avg_heat):
        return avg_heat >= self.heat_threshold


def simulated_modbus_read():
    """
    Fake Modbus reads.
    Returns (speed_rpm, current_a).
    Most of the time: speed stays near nominal and current stays moderate.
    Occasionally: simulate a microstall:
      - speed dips
      - current spikes or stays high
    """
    nominal_speed = 6000
    nominal_current = 5.0

    # Random noise
    speed = nominal_speed + random.uniform(-150, 150)
    current = nominal_current + random.uniform(-0.5, 0.5)

    # Inject a microstall event with some probability
    if random.random() < 0.12:
        # Speed dips (motor not moving as expected)
        speed *= random.uniform(0.65, 0.85)
        # Current rises (load stays high)
        current *= random.uniform(1.15, 1.35)

    return max(speed, 0.0), max(current, 0.0)


def main():
    sentinel = ModbusSentinel(
        nominal_speed_rpm=6000,
        nominal_current_a=5.0,
        window_size=30,
        heat_threshold=0.35,
    )

    poll_interval_s = 0.2  # 200ms polling, typical edge-friendly pace
    for i in range(200):
        speed_rpm, current_a = simulated_modbus_read()

        avg_heat = sentinel.add_sample(speed_rpm, current_a)
        alarm = sentinel.check_alarm(avg_heat)

        print(
            f"[t={i*poll_interval_s:5.1f}s] "
            f"speed={speed_rpm:7.1f} rpm  current={current_a:4.2f} A  "
            f"avg_heat={avg_heat:0.3f}  alarm={alarm}"
        )

        if alarm:
            print(">>> MICROSTALL RISK DETECTED (edge sentinel alarm)")

        time.sleep(poll_interval_s)


if __name__ == "__main__":
    main()

What I observed when running it

At first, avg_heat stays low and alarm=False. When the simulator injects a microstall, the next few samples ramp up the window average, and the script flips to alarm=True quickly. The “few samples delay” is intentional: averaging reduces false alarms from noise.

How this maps to real Modbus (register reads)

In a real setup, you’d replace simulated_modbus_read() with actual Modbus calls. The alarm logic stays the same.

If your machine exposes:

• speed at register 40001 (example)
• current at register 40002 (example)

…then your edge loop would read those registers and pass them into sentinel.add_sample(speed_rpm, current_a).

One tiny improvement I learned the hard way: don’t average forever

I initially used a larger window, and alerts came too late. Microstalls are short and frequent in some processes, so I switched to a modest window (window_size=30 at 200ms polling = ~6 seconds of context). That gave me:

• fast enough detection
• stable enough readings to ignore small fluctuations

Wrap-up

I built an edge “microstall sentinel” that converts Modbus-like spindle telemetry (speed + current) into a sliding-window heat score and triggers an immediate alarm when the pattern looks like load without motion. The big takeaway from tinkering: keep the detection logic simple, run it locally at the edge, and use a short averaging window so you catch brief events without drowning in noise.