Robotic Lower-Limb Prosthesis Control

Legged Systems Group, Robotics Institute | Carnegie Mellon University | Ongoing

Amputees suffer from increased energy consumption, and this is aggravated by mechanically passive prostheses. Active prostheses can help by performing positive work while walking. However, high-level decisions are needed to control the behavior of the prosthesis. These high-level control decisions are dependent on the state of the robotic leg, as well as the human’s intent.

In this work, I develop the control stack for the prosthesis, from reading raw sensor frames to commanding the motors. I implement two high-level controllers, the bioinspired Neuromuscular Control for the stance phase of walking, and the Minimum Jerk Control for the swing phase. The high level controller consumes the prosthesis state, as well as human hip features to make control descisions. Here, I implement an Error State Kalman Filter to estimate the hip angle and position by fusing two IMUs. Finally, I test the controllers on an instrumented treadmill and tune them to the human’s comfort.

Hardware Overview

The leg itself was designed and built in earlier work in the lab [1]. The motors on the leg are controlled by Elmo motor drives, one each for the knee and ankle. Ground reaction sensors and two encoders per joint feed a custom MCU. The drives and the MCU talk to a Jetson Orin over EtherCAT protocol.

The EtherCAT interface is built on PySOEM, a Python library. Raw sensor data is fed into a state estimator, which outputs the state used by the high-level controller, the low-level controller then uses that output to command the motors.

Both the knee and ankle joints are series-elastic, which means the joint and the motor are connected through a spring, which lets us measure torque for free, from the spring deflection rather than a dedicated torque sensor. The low-level controller implemented here is velocity-based SEA control. It computes a velocity command and a feedforward torque from a dynamic model of the rotor, and sends the velocity command to the drives in velocity mode.

State Estimation

The pose of the human leg (thigh) is estimated by an Error State Kalman Filter [2, 3] that fuses two IMUs and the joint encoders. The two IMUs are placed on the prosthesis foot and the human thigh. The foot IMU is corrected using ZUPT (Zero-velocity update) [4, 5] and the thigh IMU is corrected by propagating the foot IMU’s readings through forward kinematics, using the joint angles read from the encoders.

Control

The Neuromuscular controller [6] is a model based controller that computes stance phase joint torques by simulating muscles and neural pathways. It was first applied to a powered prosthesis on this platform in [1]. We simulate three muscle groups, namely Vasti, Gastrocnemius and the Soleus group. Based on the current joint angles and the hip angle, the muscles generate forces, from which desired torques are computed through the moment arm. The torques are then tracked by the velocity based SEA control.

During swing, the controller computes minimum jerk reference trajectories for the knee and the ankle, such that the jerk (the rate of change of acceleration) is minimum across the trajectory. If we use the Euler-Lagrange equation to compute the minimum, we realize that the trajectory is just a quintic polynomial, so it costs almost nothing in real time to compute the trajectory.

Testing

We test the controllers by walking with the prosthesis on a split-belt instrumented treadmill. We use a bypass socket so able-bodied individuals can use the prosthesis and test the controllers.

What next?

A common source of control errors I encountered during testing was the state machine that switches between swing and stance based on contact. To avoid these switches, I want to develop an end-to-end controller that does not rely on finite states.

Reinforcement learning is a promising way to learn such a controller, but it needs an accurate model of the human and prosthesis system to learn from. So I’m exploring how we can simulate that system, learn the control policy in simulation, and deploy it zero-shot without extensive tuning on hardware.

References