Optimization-free Ground Contact Force Constraint Satisfaction in Quadrupedal Locomotion

11/24/2021
by   Eric Sihite, et al.
Northeastern University
0

We are seeking control design paradigms for legged systems that allow bypassing costly algorithms that depend on heavy on-board computers widely used in these systems and yet being able to match what they can do by using less expensive optimization-free frameworks. In this work, we present our preliminary results in modeling and control design of a quadrupedal robot called Husky Carbon, which under development at Northeastern University (NU) in Boston. In our approach, we utilized a supervisory controller and an Explicit Reference Governor (ERG) to enforce ground reaction force constraints. These constraints are usually enforced using costly optimizations. However, in this work, the ERG manipulates the state references applied to the supervisory controller to enforce the ground contact constraints through an updated law based on Lyapunov stability arguments. As a result, the approach is much faster to compute than the widely used optimization-based methods.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

05/25/2021

Unilateral Ground Contact Force Regulations in Thruster-Assisted Legged Locomotion

In this paper, we study the regulation of the Ground Contact Forces (GRF...
10/28/2021

Modeling, simulation, and optimization of a monopod hopping on yielding terrain

Legged locomotion on deformable terrain is a challenging and open robo-p...
03/29/2021

Rough-Terrain Locomotion and Unilateral Contact Force Regulations With a Multi-Modal Legged Robot

Despite many accomplishments by legged robot designers, state-of-the-art...
10/06/2021

Real-time Optimal Landing Control of the MIT Mini Cheetah

Quadrupedal landing is a complex process involving large impacts, elabor...
09/30/2019

MPC-based Controller with Terrain Insight for Dynamic Legged Locomotion

We present a novel control strategy for dynamic legged locomotion in com...
05/21/2021

Reduced-Order-Model-Based Feedback Design for Thruster-Assisted Legged Locomotion

Real-time constraint satisfaction for robots can be quite challenging du...
09/20/2019

Formal Connections between Template and Anchor Models via Approximate Simulation

Reduced-order template models like the Linear Inverted Pendulum (LIP) an...
This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

In this work, we will report our preliminary results in the modeling, control design, and development of a legged robot called NU’s Husky Carbon (shown in Fig. 1). Our objective is to integrate legged and aerial mobility into a single platform.

Robotic biomimicry of animals’ multi-modal locomotion can be a significant ordeal. The prohibitive design restrictions such as tight power budget, limited payload, complex multi-modal actuation and perception, an excessive number of active and passive joints involved in each mode, sophisticated control, and environment-specific models, just to name a few, have alienated these concepts. It is worth noting that as how multi-modality has secured birds’ (and other species) survival in complex environments, similar manifestations in mobile robots can be rewarding and important.

Fig. 1: NU’s Husky Carbon, the platform to integrate legged and aerial mobility.

Payload is a key factor for aerial systems. We are seeking control design paradigms that allow bypassing costly algorithms that depend on heavy on-board computers widely used in legged systems and yet being able to match what they can do using less expensive optimization-free frameworks. In this work, we will present our optimization-free approach based on path planning in the state space of the robot. Our constraints are bounded unilateral ground contact forces which are important to avoid the violation of gait feasibility conditions. The resulting algorithms can run faster and can be hosted by lightweight processors.

From a feedback design standpoint, the challenge of simultaneously providing asymptotic stability and gait feasibility constraints satisfaction in legged systems (bipedal and multi-pedal) has been extensively addressed [apgar_fast_2018, bledt2020regularized, hutter_anymal_2016]. For instance, the works by [westervelt2007feedback] have provided rigorous model-based approaches to assign attributes such as the efficiency of locomotion in off-line fashions.

Other attempts entail optimization-based, nonlinear approaches to secure safety and performance of legged locomotion [nguyen2015optimal, CLFQP, ames_rapidly_2014, hereid20163d, sentis2006whole]. In general, in these paradigms, an optimization-based controller adjusts the gait parameters throughout the whole gait cycle such that not only the robot’s posture is adjusted to accommodate the unplanned posture adjustments but also the joints position, velocity, and acceleration are modified to avoid slipping into infeasible scenarios, e.g., the violation of contact forces. What makes these methods cumbersome is that they are widely defined based on whole-body control at every time-step which can lead to computationally expensive optimization problems.

Many of today’s real-time approaches have achieved better efficiencies through reduced-order models and decomposition methods [buschmann_collocation_2007], however, they still depend on optimization solvers [koolen_design_2016, fahmi_passive_2019, dario_bellicoso_perception-less_2016, bretl_testing_2008, pardo_evaluating_2016, mastalli_trajectory_2017, mastalli_-line_2015, winkler_gait_2018, aceituno-cabezas_simultaneous_2018, dai_planning_2016]. While many optimization-based methods do not present promising horizons in experimental legged robotics, other Gauss-Newton Hessian approximation such as Sequential Linear Quadratic (SLQ) [sideris_efficient_nodate], iLQR and iLQG [todorov_generalized_2005] have been more effective. That said, they also present formidable challenges for smaller processors.

Other popular paradigms such as Approximate Dynamic Programming (ADP) [powell2007approximate]

, Reinforcement Learning (RL)

[sutton2018reinforcement], decoupled approaches to design control for nonlinear stochastic systems [rafieisakhaei2017near] can potentially remedy the challenges associated with costs of computation. However, these approaches are far from providing any practical solutions to the problem at hand and they are shown to be only effective on simpler practical robots [berseth_progressive_2018, heess_emergence_2017, peng2015learning, xie_feedback_2018, haarnoja_composable_2018, mahmood_benchmarking_2018, haarnoja_learning_2019, haarnoja_reinforcement_2017] and demonstrations in more complex problems such as those offered by legged robots are missing.

In this work, we will resolve gait parameters for our quadrupedal platform off-line and re-plan them in real-time during the gait cycle. We assume well-tuned supervisory controllers found in [sontag1983lyapunov, 371031, bhat1998continuous] and will focus on fine-tuning the joints’ desired trajectories to satisfy unilateral contact force constraints. To do this, we will devise intermediary filters based on Explicit Reference Governors (ERG) [411031, bemporad1998reference, gilbert2002nonlinear, dangol2020towards, dangol2020performance, liang2021rough]. ERGs relied on provable Lyapunov stability properties can perform the motion planning problem in the state space in a much faster way than widely used optimization-based methods.

Ii Overview of Northeastern University’s Husky Carbon Morpho-functional Platform

Husky Carbon [ramezani2021generative], shown in Fig. 1

, when standing as a quadrupedal robot, is 2.5 ft (0.8 m) tall, is 12 in (0.3 m) wide. The robot was fabricated from reinforced thermoplastic materials through additive manufacturing with a total weight of 9.5 lb (4.3 kg). It hosts on-board power electronics and it operates using an external power supply. The current prototype lacks exteroceptive sensors such as camera and LiDAR. The robot is constructed of two pairs of identical legs in the form of parallelogram mechanisms. Each with three degrees-of-freedom (DOFs), the legs are fixated to Husky’s torso by a one-DOF revolute joint with a large range of motion. As a result, the legs can be located sideways. This configuration allows facing the knee actuators upwards for propulsion purposes. A clutch mechanism will disengage the knee actuator from the lower limb before the actuator runs a propeller.

Iii System dynamic modeling and controller

Husky can be modeled using the simple reduced-order model where the leg is assumed to be massless and all masses are incorporated into the body. Then the system has 6 dynamical DOFs representing the body’s linear position and orientation. Each leg is modeled using two hip angles (frontal and sagittal) and a prismatic joint to describe the leg end position. This results in a very simplified model which we will use in a numerical simulation.

Iii-a Husky Reduced Order Model (HROM)

The Husky Reduced Order Model (HROM) can be derived using Euler-Lagrangian dynamics formulation where the full conformation of Husky as shown in Fig. 1 are simplified by assuming massless legs and modeling them as variable-length linkages from the center of mass to the foot end positions. These virtual legs can be defined using two rotations and length variables, and the ground reaction forces (GRF) are applied at the foot end positions which will perturb the system.

Let the superscript

represent a vector defined in the body frame (e.g.,

), and the rotation matrix represents the rotation of a vector from the body frame to the inertial frame (e.g., ). The foot end positions can be derived using the following kinematics equations:

(1)

where is the body position, is the position of foot where is the set of legs, and are the hip frontal and sagittal angles respectively, and is the prismatic joint length.

Let be the body angular velocity in the body frame and be the gravitational acceleration vector. The legs of HROM are massless, so we can ignore all leg states and directly calculate the kinetic energy and potential energy . Then the Lagrangian of the system can be calculated as and the dynamic equation of motion can be derived using the Euler-Lagrangian Method. The body orientation is defined using the Hamiltonian’s principles and the modified Lagrangian for rotation in SO(3) to avoid using Euler rotations which can become singular during the simulation. Then the equation of motion can be derived as follows:

(2)

where and are the generalized vectors,

is the skew operator, and

. The dynamic system acceleration can then be solved from into the following standard form:

(3)

where is the mass/inertia matrix, contains the coriolis and gravitational vectors, represent the generalized force due to the GRF () acting on the foot , and where . , , and are also a function of the leg joint variables (, , and ), which is driven by setting their accelerations to track a desired joint states. The joint states and the inputs are defined as follows

(4)

where , , and contain the joint variables of all legs (hip frontal, hip sagittal, and leg length respectively), and forms the control input to the system in the form of the leg joint state accelerations. Combining both the dynamic and massless leg states form the full system states:

(5)

where the contains the elements of the rotation matrix . The equation of motion can then simply defined as which will be implemented in a numerical simulation.

The GRF is modeled using a compliant ground model and Stribeck friction model, defined as follows:

(6)

where and are the and positions of foot respectively, and are the spring and damping coefficients of the compliant surface model respectively, and are the ground friction forces respectively, , , and are the Coulomb, static, and viscous friction coefficients respectively, and is the Stribeck velocity. We omit the derivations of as it follows similar derivations to .

Iii-B Controller and Explicit Reference Governor (ERG)

Fig. 2:

The reduced order-model represented by a triangular pendulum which is used to estimate GRF and constraints equations for ERG.

The ERG framework is used to enforce the ground force constraint during the implementation of the walking gait. The ERG is utilized by defining a cost or constraint equation as a function of the controller reference. However, calculating the GRF is very complex and difficult even in HROM, so a further simplified model is used to estimate the GRF and to derive the constraint equations.

The ROM is modeled as a triangular inverted pendulum (TIP), shown in Fig. 2, which is an extension of the more standard variable length inverted pendulum model. The two contact points at the feet allow us to estimate the distribution of GRF between the two legs so we can evaluate the friction constraint on each leg individually. The kinematic constraints of the TIP model can be defined as follows:

(7)

where and are the front and rear foot position respectively and represent the leg position from the body CoM to either foot. Assuming no slippage at the foot end points (), the body can be controlled using the leg length acceleration . In this case, the body acceleration is the control input to this simplified model which will be mapped back into the joint space accelerations () for HROM. Consider the following PD controller to track a desired body states () and velocity:

(8)

where and are the PD gains for this controller. Define the vectors and which turns (8) into the concise form of where .

The ground forces can be derived from the body acceleration, as this point mass dynamics can be modeled as follows:

(9)

where and are the GRF of the front and rear foot respectively. Since we can only solve for the sum of the ground forces from (9), we need to make some assumptions to solve for and

. This model restricts moment about the axis perpendicular to the support polygon and by assuming the lateral ground forces are distributed evenly, we can form the following constraint equations:

(10)

where is the unit vector perpendicular to the support polygon along the ground plane, and and are the distance along the support polygon as illustrated in Fig. 2. Combining (9) and (10) yields the general form equation where the GRF can be solved given that is invertible. The GRF can be defined as a function of the body position reference by plugging in (8) into (9) which will be used to derive the constraint equations for the ERG.

Iv Explicit Reference Governor

Explicit reference governor (ERG) works as an add-on scheme on a pre-stabilized closed-loop system [garone2015explicit]. The ERG manipulates the applied reference to the controller to enforce the desired constraints while being as close as possible to the desired reference trajectory.

Iv-a Constraint Equation Formulations

Some constraint equations are defined to enforce the no-slip condition on both stance feet of the robot. Let the constrain equation be defined as follows:

(11)

where the relationship between the constraint and is linear. The GRF for both feet can be solved using (8) to (10), as follows:

(12)

which is linear in . The following GRF constraints are used to prevent slipping:

(13)

Then the constraint equations can be formulated as follows:

(14)

for leg . The and in (11) can be calculated numerically using (12) and (14) which will be used to formulate the ERG applied reference update law.

Iv-B ERG Formulations

1:
2:
3:
4:
5:if  then
6:     
7:end if
8:if  then
9:     
10:     for  do
11:         
12:         if  then
13:              
14:         end if
15:     end for
16:     
17:     
18:     
19:     for  do
20:         
21:         
22:     end for
23:end if
24:if  then
25:      index of the smallest
26:     
27:     if  then
28:         
29:     else
30:         
31:     end if
32:end if
33:
34:
Algorithm 1 ERG algorithm to constraint GRFs
Fig. 3: Explicit Reference Governor (ERG) manipulates the applied reference states to be as close as possible to the desired reference without violating the constraint equation .

The ERG framework is utilized to enforce the friction pyramid constraint in (14) which is formulated into the form shown in (11). The ERG algorithm manipulates the applied reference into the controller in (8) such that (11) is satisfied. This method is very useful as it avoids using optimization or nonlinear MPC frameworks to enforce constraints on the harder-to-model GRFs.

Let be the applied reference which will be used in the controller instead of , and be the constraint equation value using . The ERG manipulates the applied reference () to avoid violating the constraint equation while also be as close as possible to the desired reference (), as illustrated in Fig. 3. Consider the Lyapunov equation . is updated through the update law:

(15)

where drives directly to , while and drives along the surface and into the boundary , respectively. The objective of this ERG algorithm is to drive to the state which is the minimum energy solution that satisfies the constraint . The overall structure of this algorithm can be seen in Algorithm 1.

Let be the rowspace of the violated constraints of (rows of the where the constraint is violated). Define where is the size of the nullspace. Additionally, let be the ’th row of . Then the following update law is used for , , and :

(16)

where are scalars defined as follows:

(17)

where is a positive scalar which determines the rate of convergence.

Assuming and using the update law defined from (16) and (17), we will have , with . We have the gradient if and , while when or when . In case both applied reference and target constraints equation are violated, we have which drives the towards the constraint boundary. This allows the to converge to which is the minimum energy solution that satisfies as illustrated in Fig. 3.

V Numerical Simulation

Fig. 4: Simulated states of the Husky as it walks stably on a slippery surface () for 20 walking steps.
Fig. 5: The simulated GRF on the front and rear stance foot, labeled as 1 and 2 respectively, during the first four gait periods. The ground friction stayed within the friction pyramid constraints which are shown as the dashed lines.
Fig. 6: The constraint equation values between using the applied vs. target reference during the first two gait periods. The initial reference cause constraint violation which is avoided using the ERG update law.
Fig. 7: The target vs applied references (body linear position and velocity) during the period of constraint violation of the target references. The applied reference is manipulated to avoid breaking the constraints.

The simulation was implemented on HROM based on a predefined quasi-static trotting gait in MATLAB. The stance-swing pair switching was done by using a timing-based state machine, where the gait period is defined as 0.25 s and a total of 20 walking steps was simulated. The input of the ERG and the stance foot controller in (8) is defined as the inertial frame foot end acceleration relative to the current body position. To implement this controller, we simply integrated this acceleration to the desired position and velocity about the body frame, and track these positions using a PID controller. The swing foot trajectory follows a simple bezier curve trajectory with an end position located at a fixed position relative to the body (0.08 m ahead of hip position in the x-axis). The bezier curve trajectory initial position is set as the previous stance foot final position and a target swing height of 0.2 m with zero initial and final velocity. Since we have no row, pitch, or yaw compensation, we rotate the reference by at every time step so that the robot acts like walking on a flat surface without angular deviation.

The simulation results of the robot walking on slippery surface () at the target forward speed of 0.2 m/s is shown in Fig. 4 to 7. The resulting gait is stable, with a potential slipping happening at the beginning of the gait which is regulated by the ERG as shown in Fig. 5 and 7. The ERG has successfully manipulated the controller reference states to avoid constraint violation which resulted in a stable trotting gait even on a slippery surface. Figure 5 shows the actual GRF applied to this robot during this simulation and the friction is kept within the constraint boundary defined in (13).

This simulation was performed in Matlab using a computer with AMD Ryzen six-core 3.40 GHz processor and 16 GB of RAM. Each simulation time step which includes the ERG computation and ODE integration with 4th order Runge-Kutta algorithm was computed at a rate of approximately 2 kHz. Most embedded systems are programmed in C or C++ which are significantly faster than Matlab. This shows that our ERG algorithm can be utilized in real-time computations using the robot’s on-board computer.

Vi Conclusions and future work

We explored the performance of the ERG algorithm on a quadruped where the no-slip constraints have been enforced successfully. The use of ERG allows the robot to walk stably on a slippery surface () where the controller states are manipulated to satisfy the GRF constraints we specified. This algorithm can be computed quickly, which means that it can serve as an alternative to the more computationally expensive algorithms for enforcing constraints, such as optimization and whole-body control.

The controller considered in this work is only defined for the stance foot where the GRF is applied. Future work should include the usage of the swing foot placement algorithm to regulate the robot heading and the tracking of more complex trajectories. Additionally, other constraints can also be considered for the ERG, such as input and state saturation constraints which are practical for the implementation in the actual robot.

References