← Latest papers
💻 computer science

Four Simple Proprioceptive Estimators for Legged Robots

This paper presents four increasingly expressive proprioceptive state estimators for legged robots that mitigate IMU drift by leveraging intermittent foot contacts, ranging from a contact-aided invariant EKF to a fixed-lag smoother, all implemented in GTSAM and ROS2 for reproducibility.

Original authors: Frank Dellaert, Chiyun Noh, Varun Agrawal, Ayoung Kim

Published 2026-05-25
📖 5 min read🧠 Deep dive

Original authors: Frank Dellaert, Chiyun Noh, Varun Agrawal, Ayoung Kim

Original paper licensed under CC BY 4.0 (http://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

Imagine a legged robot (like a four-legged dog) trying to walk through a dark room without bumping into things. To know where it is, the robot relies on two main sources of information, but both have flaws:

  1. The "Gyroscope" (IMU): This is a sensor that spins and shakes to tell the robot how it's moving. It's very fast and works all the time. However, it's like a drunk person trying to count their steps; over time, it gets slightly confused, and its estimate of where the robot is starts to drift away from reality.
  2. The "Feet": When a foot touches the ground, it stops moving relative to the floor. This is a perfect, solid anchor. But the robot only has this information when a foot is actually planted. When the foot is swinging in the air, this anchor disappears.

The paper "Four Simple Proprioceptive Estimators for Legged Robots" is essentially a recipe book for four different ways to combine these two messy sources of information to keep the robot from getting lost. The authors built four versions of a "calculator" (an estimator) that gets progressively smarter at using the feet to correct the drifting gyroscope.

Here is the breakdown of the four approaches, using simple analogies:

1. The "One-Step-at-a-Time" Calculator (Invariant EKF)

The Analogy: Imagine you are walking in the dark, counting your steps (the gyroscope). Every time you feel your foot hit the ground, you pause, look at your step count, and make a tiny correction to your mental map.
How it works: This is the simplest method. It predicts where the robot is based on the gyroscope, and the moment a foot touches the ground, it instantly fixes the error. It treats the foot as a temporary landmark.
The Catch: It does this correction one foot at a time, in a specific order. If two feet touch the ground at the exact same time, it might process them sequentially, which isn't perfectly efficient.

2. The "Group Think" Calculator (Graph-Update Filter)

The Analogy: Now, imagine that when your feet hit the ground, instead of correcting your map one by one, you gather all the feet that are touching the ground right now and ask them to agree on a single, perfect correction together.
How it works: This version is almost the same as the first one, but when the robot updates its position, it looks at all the active feet simultaneously. It solves a tiny math puzzle to find the best spot that satisfies all the feet at once.
The Result: It's slightly more accurate because it doesn't force an arbitrary order on the corrections, but it's still a "one-step" approach.

3. The "Sliding Window" Calculator (Fixed-Lag Smoother with One Bias)

The Analogy: Imagine you are walking in the dark, and you keep a short "memory tape" of the last few seconds. Instead of just looking at this step, you look at the last few steps and all the footprints you've made recently. You realize, "Wait, if I look at the last 5 seconds of movement, my gyroscope seems to be drifting a little bit to the left."
How it works: This method keeps a small window of history (the last few seconds). It treats every time a foot touched the ground as a specific "event" in history. It uses all the data in that window to smooth out the path. It assumes the gyroscope's error (the "drunk" part) stays roughly the same during that short window.
The Result: This is much better at preventing the robot from drifting over long distances because it can look back and fix mistakes using future information.

4. The "Adaptive" Calculator (Fixed-Lag Smoother with Evolving Bias)

The Analogy: This is the most sophisticated version. It's like the robot realizing, "My gyroscope isn't just slightly off; it's getting more off the longer I walk, maybe because it's getting hot or tired." So, instead of assuming the error is the same for the last 5 seconds, it assumes the error is slowly changing and evolving.
How it works: It keeps the "sliding window" of history, but it allows the gyroscope's error to change over time within that window. It models the error as a journey rather than a static number.
The Result: This is the most flexible and powerful method for long walks or changing environments, as it can adapt to the sensor getting "tired."

What Did They Find?

The authors tested these four calculators on a real robot (Boston Dynamics' Spot) walking through various terrains, including flat floors, stairs, and slopes.

  • The Good News: All four methods were excellent at keeping the robot from getting lost, especially compared to other existing methods. They proved that you don't need expensive cameras or lasers (which are often used for this) if you have a good math model for the feet and the gyroscope.
  • The Trade-off:
    • The simplest methods (1 & 2) were very stable but didn't correct long-term drift as well.
    • The sliding window methods (3 & 4) were the best at keeping the robot on the right path over long distances.
    • The Twist: The most complex method (Method 4, the "Adaptive" one) was great at keeping the robot moving forward correctly, but sometimes it got a little confused about height (up and down) on steep stairs. The slightly simpler "Sliding Window" (Method 3) was sometimes better at keeping the vertical height accurate.

The Bottom Line

The paper shows that by changing how a robot "thinks" about its feet and its internal sensors—moving from a simple step-by-step fix to a memory-based, history-smoothing approach—you can make legged robots much more reliable. They didn't just invent a new sensor; they invented a better way to do the math with the sensors they already have.

All four of these "calculators" are now available as open-source code for other researchers to use and improve upon.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →