⚡ electrical engineering

Experiments with Higher Order Sliding Mode Differentiators: Practical Considerations

This study empirically evaluates higher-order sliding mode differentiators on a servomotor to demonstrate that replacing the discontinuous sign function with a saturation function can mitigate stability and accuracy degradation caused by low sampling rates, thereby providing practical implementation guidelines for hardware-constrained applications.

Original authors: Jessica Hamer, Farbod Fahimi

Published 2026-09-01

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Jessica Hamer, Farbod Fahimi

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the world of robotics and automated machinery, machines need to know not just where they are, but how fast they are moving and how quickly that speed is changing. This information is crucial for keeping a robotic arm steady or a drone hovering in place. However, the sensors that tell a machine its position are often noisy, sending back a jumpy, imperfect signal. To get the speed and acceleration from this shaky position data, engineers use mathematical tools called differentiators. Think of these tools as a way to smooth out the noise and calculate the rate of change. For decades, a popular family of these tools, known as sliding mode differentiators, has been celebrated in computer simulations for its ability to cut through noise and deliver precise answers almost instantly. These simulations, however, often run in a perfect, continuous world where data flows without interruption.

The real world is not so smooth. Real machines run on digital computers that take snapshots of data at fixed, often slow, intervals. When these ideal mathematical tools are forced to run on real hardware with limited speed, the results can be disastrous. The very feature that makes them robust in theory—their sharp, instant switching between states—can turn into a violent shaking known as chattering. This shaking can destroy the accuracy of the speed estimate, rendering the machine's control system useless. This gap between the perfect world of simulation and the messy reality of physical sensors is the central problem researchers Jessica Hamer and Farbod Fahimi set out to solve. They wanted to find out which mathematical settings actually work when the clock is ticking slowly, and which ones are merely illusions created by fast computers.

To find the truth, the researchers built a testbed using a standard servomotor, a common type of electric motor used in robotics. They connected this motor to a small computer board and programmed it to move in precise steps. The motor's position was measured by a sensor, and the researchers fed this raw data into three different mathematical algorithms designed to estimate the motor's speed. They tested these algorithms under a variety of conditions, specifically changing how often the computer took a snapshot of the motor's position. They ran tests at sampling rates of 100, 50, 25, and 10 times per second, a range that covers everything from high-performance industrial robots to slower, more constrained embedded systems.

The researchers also tested two different ways the algorithms could make their decisions. The first was a sharp, discontinuous switch that jumps instantly from one value to another, much like a light switch being flipped on and off. The second was a smoother approach that allowed for a small, gradual transition zone, softening the jump. By mixing these switching styles with the different sampling speeds, they created a matrix of 16 different scenarios to see which combination survived the transition from theory to practice. They measured the results by comparing the estimated speed against the known, theoretical speed of the motor, looking for two main things: how much the estimate wobbled around the true value, and how far off the average estimate was from the truth.

The results revealed a stark divide between what works in theory and what works in reality. When the computer sampled the motor's position very quickly, at 100 times per second, the sharp, discontinuous switching method performed beautifully for two of the algorithms tested. It provided fast, accurate speed estimates with very little noise. However, as the sampling rate slowed down, the sharp switching method began to fail. At 50 and 25 times per second, the estimates became jittery and unreliable, with the error growing significantly. At the slowest rate of 10 times per second, the sharp switching method collapsed entirely, producing estimates that were wildly inaccurate and unusable for any real control task.

The solution, the researchers found, was to replace the sharp switch with the smoother transition zone, but only if the size of that zone was tuned correctly. When the sampling rate dropped to 50 or 25 times per second, switching to the smoother method with a very thin transition zone restored the accuracy to levels nearly identical to the high-speed tests. This was a critical discovery: it meant that engineers could potentially run these powerful algorithms on slower, cheaper, or less powerful hardware without sacrificing performance, provided they adjusted the smoothing parameter. However, this fix had limits. At the lowest speed of 10 times per second, even the smoothest transition could not save the algorithm; the data simply arrived too slowly for the math to keep up, and the estimates remained poor.

The study also compared two different families of algorithms. One family, known as the Ghanes method, offered a flexible design that could switch between different modes of operation. The researchers found that while one mode of this method worked well at high speeds, a fully linear version of it failed to provide any viable solution at any speed tested. The other family, based on the work of Basin, included both second-order and third-order versions. The second-order version, which estimates speed, worked well at high speeds but struggled at lower speeds unless the smoothing technique was applied. The third-order version, which attempts to estimate acceleration as well, showed a tendency to overshoot the target speed significantly, making it less suitable for applications where rapid changes in speed occur, unless the acceleration estimate was strictly required.

Ultimately, the paper provides a clear set of guidelines for engineers building real-world systems. It confirms that the high-speed, sharp-switching methods often seen in textbooks are not always the best choice for physical hardware. Instead, the study suggests that for systems operating at moderate speeds, a carefully tuned smoothing technique can rescue performance, allowing for accurate speed estimation even when the computer cannot sample data very quickly. However, there is a hard floor: if the sampling rate drops too low, no amount of mathematical tweaking can recover the lost accuracy. The work serves as a practical map, showing where the theoretical tools of control engineering can safely be deployed and where they will stumble, ensuring that the next generation of robots and machines can rely on their sensors to keep them moving smoothly.

Technical Summary: Experiments with Higher Order Sliding Mode Differentiators

Problem Statement

Numerical simulations of Sliding Mode Differentiators (SMDs) often rely on idealized continuous-time conditions, utilizing variable time-step integration and ultra-high sampling rates (kilohertz range). These conditions obscure critical practical challenges inherent in discrete-time implementations, such as fixed integration steps, low sensor sampling rates, and severe numerical chattering. Consequently, standard discontinuous switching functions (e.g., sign()) often perform impeccably in simulation but fail or degrade significantly in real-world hardware applications where sampling frequencies may drop to the 10–100 Hz range. There is a lack of empirical guidelines for selecting viable SMD configurations under these hardware-constrained conditions, particularly regarding the trade-offs between sampling rates and the choice of switching functions (discontinuous sign() vs. continuous boundary-layer sat()).

Methodology

This study empirically evaluates the performance of three differentiator algorithms using real-time position measurements from a servomotor. The experimental platform consists of a Raspberry Pi 4, a MyActuator X-6 servomotor, and a ROS2-based distributed control system. The algorithms were tested across a range of sampling frequencies (10 Hz, 25 Hz, 50 Hz, and 100 Hz) and switching function configurations.

Algorithms Implemented:

Ghanes's Hybrid Algorithm: A second-order differentiator combining super-twisting behavior with linear observer robustness. The study simplified the original formulation by bypassing the adaptive high-pass filter and fixing the exponent $\alpha$ to either 0.5 (super-twisting mode) or 1.0 (linear mode).
Basin's Higher-Order Sliding Mode (HOSM) Differentiator: Based on fixed-time convergence formulations, implemented in two configurations:
- Second-order ( $n=2$ ): Estimates position and velocity.
- Third-order ( $n=3$ ): Estimates position, velocity, and acceleration.

Experimental Design:

Integration: A fifth-order Adams-Bashforth method was used for fixed-step numerical integration.
Switching Functions: The discontinuous sign() function was compared against the continuous saturation function sat(s, φ) with varying boundary layer thicknesses ( $\phi = 0.001, 0.05, 0.1$ ).
Metrics: Performance was quantified using Mean Squared Error (MSE), Standard Deviation (STD) to measure chatter, and Mean value deviation. Analysis focused on the steady-state velocity estimation after the initial transient rise.
Scope: A total of 64 trials were conducted (4 algorithms $\times$ 16 test scenarios).

Key Results

1. Ghanes's Method

Nonlinear Mode ( $\alpha = 0.5$ ):
- At 100 Hz, the sign() function provided fast convergence but exhibited chattering. Replacing it with sat() at a small boundary layer ( $\phi = 0.001$ ) significantly reduced chattering (STD) and MSE without compromising accuracy. Larger $\phi$ values increased rise time and error.
- At 50 Hz and 25 Hz, the sign() function resulted in severe degradation of accuracy and increased chattering compared to the 100 Hz baseline. However, switching to sat() with $\phi = 0.001$ restored performance to levels nearly identical to the 100 Hz sat() case.
- At 10 Hz, performance collapsed. Even the sat() function with $\phi = 0.001$ failed to attenuate chatter or maintain accuracy, rendering 10 Hz impractical for this method.
Linear Mode ( $\alpha = 1.0$ ): This configuration produced unfavorable results across all sampling rates and switching functions, offering no viable solutions.

2. Basin's Second-Order Method

100 Hz: The sign() function yielded minimal chattering. Introducing a boundary layer ( $\phi = 0.001$ ) slightly improved STD but worsened MSE due to overshoot. Larger $\phi$ values significantly degraded performance. The authors conclude that using a boundary layer at 100 Hz is not recommended.
50 Hz: The sign() function led to noticeable chattering and poor results. However, using sat() with $\phi = 0.001$ recovered performance to match the 100 Hz sat() baseline.
25 Hz and 10 Hz: The integration algorithm diverged at these rates, proving them too low for this method.

3. Basin's Third-Order Method

100 Hz: The sign() function exhibited prominent overshoot but minimal chattering. Adding a boundary layer ( $\phi = 0.001$ ) increased overshoot and worsened both STD and MSE. Larger $\phi$ values caused significant fluctuations. The authors advise against using a boundary layer at 100 Hz for this method.
50 Hz: Similar to the second-order case, the sign() function resulted in extreme chattering. The sat() function with $\phi = 0.001$ restored performance to levels comparable to the 100 Hz sat() baseline.
25 Hz and 10 Hz: The integration algorithm diverged, making these rates impractical.

Significance and Claims

The paper claims to provide concrete empirical guidelines for implementing SMDs in real-world, hardware-constrained applications where high sampling rates are not feasible. The primary contributions are:

Restoration of Accuracy at Lower Sampling Rates: The study demonstrates that for Ghanes's method and Basin's methods (at 50 Hz), the severe accuracy degradation and chattering caused by dropping sampling rates from 100 Hz to 50 Hz can be mitigated by replacing the discontinuous sign() function with a saturation function sat() with a small boundary layer thickness ( $\phi = 0.001$ ).
Sampling Rate Limits: The work establishes practical lower bounds for these algorithms. While 50 Hz is viable with specific tuning, 25 Hz and 10 Hz are identified as too low to achieve derivative accuracy for the tested configurations, as the integration algorithms diverged at these rates.
Algorithm-Specific Tuning:
- Ghanes's Method: Best utilized in nonlinear mode ( $\alpha=0.5$ ) with sat() at $\phi=0.001$ for rates between 25 Hz and 100 Hz.
- Basin's Method: Best utilized with the sign() function at 100 Hz. If 100 Hz is unavailable, 50 Hz is viable only if the sat() function with $\phi=0.001$ is used.
Order Selection: The third-order Basin method exhibits significantly higher overshoot than the second-order version. The authors advise using the second-order method if only velocity estimation is required, reserving the third-order method for cases where acceleration estimation is strictly necessary.

The authors maintain a modest tone, emphasizing that these findings are specific to the tested servomotor setup and algorithm parameters, and do not claim universal applicability to all systems without further validation.